UNIT-1

Introduction to software engineering- scope of software engineering, historical aspects, economic aspects, maintenance
aspects, specification and design aspects, team Programming aspects. Layered technology, processes, methods and
tools. Phases in Software development

Process models- prescriptive process models- waterfall model, incremental models, Evolutionary models and concurrent
models

Scope of software engineering

The scope of software engineering encompasses the entire process of designing, developing, testing, deploying,
and maintaining software applications, utilizing engineering principles to ensure high quality, reliability, and efficiency,
covering activities like requirement analysis, system design, implementation, verification, validation, and project
management across various stages of the software development lifecycle (SDLC) to deliver functional and reliable
software solutions that meet user needs within specified constraints like time and budget.

Key aspects of the software engineering scope:

Requirement Analysis:

Gathering and defining detailed user needs, identifying functional and non-functional requirements, and translating
them into technical specifications.

System Design:

Creating a blueprint for the software architecture, including component breakdown, data flow, interface design, and
system interactions.

Implementation:

Writing code using programming languages, adhering to coding standards and best practices to translate the design into
a working software system.

Testing and Quality Assurance:

Performing various testing methods (unit, integration, system, acceptance) to identify and resolve defects, ensuring the
software meets quality standards.

Deployment:

Delivering the software to the intended environment, including installation, configuration, and deployment procedures.

Maintenance and Evolution:

Ongoing support after deployment, addressing bug fixes, updates, enhancements, and adapting to changing
requirements.

Software Engineering Specializations:

Web Development:

Designing and building interactive web applications using front-end technologies (HTML, CSS, JavaScript) and back-end
technologies (Java, Python, etc.).
Mobile App Development:

Creating applications for mobile devices (iOS, Android) with specific platform considerations.

Embedded Systems:

Developing software for specialized hardware systems with real-time constraints, often used in IoT devices.

Data Engineering:

Designing and managing large-scale data systems, including data pipelines, data warehousing, and data analysis tools.

Cloud Computing:

Developing and deploying applications on cloud platforms, leveraging cloud services for scalability and flexibility.

Artificial Intelligence (AI) and Machine Learning (ML):

Designing and implementing AI/ML algorithms for various applications like image recognition, natural language
processing, and predictive analytics.

Important Considerations in Software Engineering Scope:

Project Management:

Planning, scheduling, resource allocation, risk management, and tracking project progress to meet deadlines and budget
constraints.

Software Architecture:

Choosing the appropriate design patterns and system architecture to ensure maintainability, scalability, and
performance.

Security:

Implementing security measures to protect sensitive data and prevent unauthorized access.

User Experience (UX) Design:

Designing user interfaces that are intuitive, user-friendly, and meet accessibility standards.

In conclusion, the scope of software engineering is vast and encompasses all aspects of the software development
process, from initial requirements gathering to deployment and ongoing maintenance, ensuring the delivery of high-
quality software solutions across diverse domains and technologies.

Historical aspects:

The history of software engineering began in the 1960s, when it was recognized as a separate discipline from computer
science.

Early development:

 1940s and 1950s

Software was considered part of computer science, and there was no distinction between hardware and software
designers

 1960s

The concept of software engineering emerged as a way to create software more systematically and efficiently

 1963

The first time-sharing system was introduced, which brought back interactivity

The software crisis:

 The 1960s saw a period of "software crisis" where software was unreliable, inefficient, and late

 The 1968 NATO conference on software engineering addressed these issues and established guidelines for
software development

Key figures:

 E.W. Dijkstra: A key figure in the early development of software engineering

 C.A.R. Hoare: A key figure in the early development of software engineering

 Tom Kilburn: Explored real-time programming, which led to the SAGE system

Later developments:

 1980s

The Ada programming language and CASE tools (Computer-Aided Software Engineering) were introduced

 1990s

The internet boom led to a demand for software engineers with web development skills

 2000s

The Agile Manifesto was introduced, which emphasized collaboration and iterative development

Economic aspects:

Software engineering economics is the study of how to relate the economic value of software to its attributes and
processes. It helps organizations maximize the value of their software, even when budgets are limited.

How does software engineering economics work?

 Economic concepts

Software engineering economics uses economic concepts like cash flows, proposals, and intangible assets to analyze
alternatives and make decisions.

 Identify intangible assets

Software engineering economics helps identify intangible assets and how they connect to business goals.
  Estimation and risk management

Software engineering economics uses estimation and risk management practices to improve software investments.

 Align technical options with business objectives

Software engineering economics helps align technical options with business objectives, even when resources are limited.

What factors influence software economics?

 Size: The size of the software

 Process: The process used to develop the software

 Personnel: The number and type of people involved in developing the software

 Environment: The environment in which the software is developed

 Quality: The quality of the software

Why is economics important for software engineers?

 Economics can help software engineers understand quantitative analysis.

 Economics can help software engineers understand scarcity and the implications of actions over time.

Maintenance aspects:

In software engineering, "maintenance" refers to the ongoing process of fixing bugs, implementing enhancements,
adapting to changing requirements, and generally ensuring a software system remains functional and relevant over
time, including activities like correcting faults, improving design, adding new features, updating interfaces, and migrating
to new platforms to accommodate changing technology and user needs.

Key aspects of software maintenance:

 Types of maintenance:

 Corrective maintenance: Fixing bugs and errors that arise in the software.

 Adaptive maintenance: Modifying the software to adapt to changing external environments or business
needs.

 Perfective maintenance: Implementing new features and enhancements based on user feedback or to
improve performance.

 Preventive maintenance: Proactive measures to identify and address potential issues before they
become significant problems.

 Factors impacting maintainability:

 Code quality: Readable, well-structured, and commented code is easier to understand and modify.

 Modularity: Breaking down code into independent modules facilitates targeted changes.
  Documentation: Clear and up-to-date documentation helps developers understand the system and
make modifications.

 Maintenance process:

 Identifying issues: Gathering feedback from users, monitoring system performance, and analyzing error
logs.

 Impact analysis: Assessing the potential consequences of changes to existing code

 Design and implementation: Developing changes to address identified issues

 Testing: Thoroughly testing modified code to ensure quality and prevent regressions

 Deployment: Integrating changes into the live system

 Importance of maintenance:

 User satisfaction: Addressing user issues and implementing requested enhancements improves user
experience

 System longevity: Keeping software up-to-date with technology advancements extends its lifespan

 Cost efficiency: Proactive maintenance can prevent major problems down the line, reducing overall
maintenance costs

Specification and design aspects:

In software engineering, "specification" refers to a detailed document outlining the desired functionalities and
behaviors of a software system, essentially defining "what" the software should do, while "design" focuses on the
technical details of how to implement those functionalities, including architecture, components, and interfaces,
essentially describing "how" the software will be built to meet the specified requirements.

Key aspects of software specifications:

 Functional requirements:

Describe the core features and functions the software should perform, including inputs, outputs, and expected
behaviors under different scenarios.

 Non-functional requirements:

Specify performance characteristics like response time, scalability, security, usability, and compatibility.

 User stories:

Describe system features from the user's perspective, often used in Agile development.

 Constraints:

Limitations or restrictions on the development process, like hardware compatibility, budget, and deadlines.

 Validation criteria:

Defines how to test and verify if the software meets the specified requirements.
Key aspects of software design:

 System architecture: The overall structure of the software, including components, modules, and their
interactions.

 Data design: How data will be stored, accessed, and manipulated within the system, including database
schema.

 Interface design: How users will interact with the software, including user interface elements and navigation.

 Algorithm design: The specific steps and logic used to implement functionalities.

 Component selection: Choosing appropriate libraries, frameworks, or pre-built components to utilize in the
development.

 Design patterns: Reusable software design solutions to address common problems.

Relationship between specification and design:

 Specification drives design:

The design process is based on the requirements and constraints defined in the software specification document.

 Design informs specification:

During the design phase, potential issues or areas of clarification might arise, leading to updates in the software
specification.

Important documents:

 Software Requirements Specification (SRS):

A detailed document outlining all the functional and non-functional requirements of the software system.

 Software Design Document (SDD):

A document that describes the chosen architecture, components, interfaces, and design decisions to implement the
specified requirements.

Team Programming aspects:

"Team programming" in software engineering refers to the collaborative process where a group of developers
work together to design, develop, and test software, emphasizing effective communication, code reviews, shared
responsibility, and coordinated efforts to achieve project goals, often utilizing methodologies like Agile to facilitate
collaboration and adaptability to changing requirements.

Key aspects of team programming in software engineering:

 Collaboration:

Developers actively share ideas, knowledge, and code, working together to solve problems and make decisions
throughout the development cycle.
  Code Reviews:

Regularly reviewing each other's code to identify potential issues, improve code quality, and ensure adherence to coding
standards.

 Pair Programming:

Two developers work together on the same task at the same computer, allowing for real-time feedback and knowledge
sharing.

 Specialization:

Teams often consist of individuals with specialized skills like front-end development, back-end development, database
management, testing, and architecture design.

 Communication:

Clear and consistent communication is vital for coordinating tasks, sharing updates, and addressing challenges.

 Agile Methodologies:

Frameworks like Scrum and Kanban promote iterative development, where teams work in short cycles with regular
feedback loops to adapt to changing requirements.

 Version Control Systems:

Utilizing tools like Git to manage code changes, track revisions, and facilitate collaboration on shared codebases.

 Team Lead Role:

A designated team leader oversees the team's progress, assigns tasks, resolves conflicts, and ensures overall project
success.

Benefits of Team Programming:

 Improved Code Quality:

Code reviews and collaborative problem-solving help identify and fix bugs early on.

 Increased Efficiency:

By sharing workload and expertise, teams can complete tasks faster and more effectively.

 Knowledge Sharing:

Team members learn from each other and gain broader understanding of the project.

 Enhanced Innovation:

Brainstorming sessions and diverse perspectives can lead to more creative solutions.

 Improved Morale:

A supportive team environment can boost individual motivation and satisfaction.

Layered technology:

Software engineering is a layered technology. Referring to Figure. (1), any engineering approach (including
software engineering) must rest on an organizational commitment to quality. Total quality management, Six Sigma, and
similar philosophies foster a continuous process improvement culture, and it is this culture that ultimately leads to the
development of increasingly more effective approaches to software engineering. The bedrock that supports software
engineering is a quality focus.

The foundation for software engineering is the process layer. The software engineering process is the glue that holds the
technology layers together and enables rational and timely development of computer software. Process defines a
framework that must be established for effective delivery of software engineering technology. The software process
forms the basis for management control of software projects and establishes the context in which technical methods are
applied, work products (models, documents, data, reports, forms, etc.) are produced, milestones are established, quality
is ensured, and change is properly managed.

Software engineering methods provide the technical how-to’s for building software. Methods encompass a broad array
of tasks that include communication, requirements analysis, design modeling, program construction, testing, and
support. Software engineering methods rely on a set of basic principles that govern each area of the technology and
include modeling activities and other descriptive techniques.

Software engineering tools provide automated or semi-automated support for the process and the methods. When
tools are integrated so that information created by one tool can be used by

another, a system for the support of software development, called computer-aided software engineering, is established.

Phases in software development:

Software development follows a structured process known as the Software Development Life Cycle (SDLC). The key
phases in software development are:

1. Planning

 Define project scope and objectives

  Conduct feasibility study (technical, operational, economic)

 Identify risks and resource requirements

 Develop a high-level project plan

2. Requirement Analysis

 Gather and analyze user and system requirements

 Document functional and non-functional requirements

 Create Software Requirement Specification (SRS) document

 Get approval from stakeholders

3. Design

 Architectural Design: Define system structure and technology stack

 UI/UX Design: Design user interfaces and experience

 Database Design: Define data structures and storage mechanisms

 Create detailed design documents

4. Implementation (Coding/Development)

 Convert design into actual software code

 Follow best coding practices and standards

 Use version control systems (e.g., Git)

 Perform unit testing

5. Testing

 Conduct various testing types:

o Unit Testing

o Integration Testing

o System Testing

o User Acceptance Testing (UAT)

 Identify and fix bugs

6. Deployment

 Deploy software in production or client environment

 Perform final system checks and monitoring

 Conduct user training and documentation

7. Maintenance & Support

 Monitor system performance

 Fix bugs and security issues

 Release updates and improvements

 Provide technical support

These phases ensure a systematic approach to software development, reducing risks and improving efficiency. Some
modern methodologies like Agile and DevOps iterate through these phases rapidly.

PRESCRIPTIVE PROCESS MODEL

Prescriptive process models define a distinct set of activities, actions, tasks, milestones and work products that are
required to engineer high quality software. These process models are not perfect, but they do provide a useful roadmap
for software engineering work.

Software engineers and their managers adapt a prescriptive process model to their needs and then follow it. It also adapt
to the process model to accommodate the specific nature for each project, the people who will do the work and the
environment in which the work will be conducted.

Software engineers have traditionally hosen a generic process framework that encompasses the following framework
activities communication, planning, modeling, construction and deployment. We call them “Prescriptive” because they
prescribe a set of process elements framework activities, software engineering actions, tasks, work products, quality
assurance and change control mechanisms for each project.

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.

Disadvantages:

 Does not allow for requirement change

 Real projects rarely follow sequential flow. although linear model can accommodate iteration, it does so
indirectly. As a result, changes cause confusion.

 No working software is produced until late during life cycle. So the customer must have patient.
 THE V MODEL

A variation in the representation of the waterfall model is called the V-model. Represented in Figure (2), the V-
model depicts the relationship of quality assurance actions to the actions associated with communication, modeling, and
early construction activities. It is based on association of a testing phase for each corresponding development stage.

Every single phase in development cycle is directly associated with testing phases. Under V-Model, there are
verification phases on one side of V and validation phases on other side. Coding phase joins two sides of V-Model.

Verification Phases:

 Requirement Analysis

 System Design

 Module Design

 Coding Validation Phases:

 Unit Testing

 Integration Testing

 System Testing

 Acceptance Testing
 V- Model illustrates how verification and validation actions are associated with earlier engineering actions. Testing of
product is planned in parallel with corresponding phase of development in V-Model.

Advantages:

 Simple and easy to use

 Proactive defect tracking-defects are found at earlier stage
 Higher chance of success over water fall model i.e.; testing activities like planning, test designing happens
well before coding. This saves a lot of time.

Disadvantages:
 If any changes happen in midway, then test document along with requirements has to be updated
 Very rigid and least flexible.
INCREMENTAL PROCESS MODELS

The incremental build a model is a method of software development where the model is designed, implemented and
tested incrementally until the product is finished.

The product is defined as finished when it satisfies all of its requirements. This model combines elements of water fall
model with iterative philosophy of prototyping. The incremental model delivers a series of relayers called incements that
provides progressively more functionality for customers as increment is delivered. The below figure shows the Incremental
model.

Ex: The word processing software is developed using incremental paradigm might delivered file management, editing and
document production functions in first increment. More sophisticated editing and document production capabilities in
second increment. Spelling and grammar checking in third increment and advanced page layout capabilities in fourth
increment.

When an incremental model is used the first increment is often a core product. That is basic requirements are addressed
but many features remain undelivered. The core product is used by customer. As a result of use and/or evaluation, a plan
is developed for next increment. The plan addresses the modification of core product to better meet needs of customer
and delivery of additional features and functionalities. This process is repeated following delivery of each increment, until
complete product is produced.
Advantages:

 More flexible-less costly to change scope and requirements.

 Each iteration is easily managed
 Easier to test and debug during smaller iteration.
Disadvantages:
 Each phase of iteration is rigid and do not overlap each other.
 Requires good analysis.
 As additional functionality is added to product, problems may arise related to system architecture which was not
evident in earlier prototypes.

EVOLUTIONARY PROCESS MODELS

Evolutionary models are iterative. They are characterized in a manner that enables you to develop increasingly more
complete versions of the software. The common evolutionary process models.

a). PROTOTYPING:

The prototyping paradigm begins with communication. You meet with other stakeholders to 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 (in the form of a “quick design”) occurs. A quick design focuses on
a representation of those aspects of the software that will be visible to end users. The quick design leads to the
construction of a prototype. The prototype is deployed and evaluated by stakeholders, who provide feedback that is used
to further refine requirements. Iteration occurs as the prototype is tuned to satisfy the needs of various stakeholders,
while at the same time enabling you to better understand what needs to be done.
Advantages:

 The prototype models give a prototype that can be used to illustrate input data formats, messages, reports,
and interactive dialogue for the customer. This is a valuable mechanism for explaining various processing
options to the customer and gaining better understanding of the customers and users.

 The prototype explores technical issues in the proposed product.

Disadvantages:

 Sometimes developer may make implementation compromises to get prototype work quickly. Later on
developer may become comfortable with compromises and forget why they are inappropriate.
 It lacks overall software quality and long term maintainability
b). SPIRAL MODEL [Risk Driven Process Model]

This model was proposed by Barry Boehm, is an evolutionary software process model that couples the iterative nature of
prototyping with controlled and systematic aspects of waterfall model. Using Spiral Model software model is developed
in a series of evolutionary releases. During early iterations release might be a model or prototype. During later iteration,
increasing more complete versions of engineering system are produced. In addition, it guides and measures the risk
management of each cycles of spiral model.

Advantages:

 Good for large projects.

 High amount or risk analysis, hence avoidance of risk is enhanced.

Disadvantages:

 Can be a costly model to use.

 Risk analysis requires highly specific expertise.

c). CONCURRENT MODELS

The concurrent development model is also called as ‘Concurrent Engineering’. In this model the framework activities are
represented as a series of tasks. For example, the modeling activity can perform in various states. These states contain
various activities or tasks.

For instance, modeling activities are going on it might be in underdevelopment state. When certain process or activities
are going on it might being awaiting changes state. Some reviews might be carried out on the developed or partially
developed software product. Hence under review of under revision might be some states. Finally, the software product
goes in done state. Sometimes some inconsistency in analysis modeling may trigger some changes in existing product.
Then for implementing those changes product has to undergo awaiting changes state.
A final comment on Evolutionary processes: Modern computer software is characterized by continual
change, by every tight timelines and by hundred percent need for customer/ user satisfaction. In many
cases time-to-market is the most important management requirement. If a market window is missed
,the software project itself may be meaningless.

Evolutionary process models were conceived to address these issues, and yet, as a general class of
process models, they too have weaknesses.

These are summarized by Nogueira and his colleagues.

i).The first concern is that prototyping poses a problem to project planning because of the uncertain
number of cycles required to construct the product .

ii).Second, evolutionary software processes do not establish the maximum speed of the evolution. If
the evolutions occur too fast, without a period of relaxation, it is certain that the process will fall into
chaos. On the other hand if the speed is too slow then productivity could be affected.

ii). Third, [evolutionary] software processes should be focused on flexibility and extensibility rather
than on high quality. This assertion sounds scary.

Indeed, a software process that focuses on flexibility, extensibility, and speed of development over
high quality does sound scary. And yet, this idea has been proposed by a number of well-respected
software engineering experts.

The objective of evolutionary models is to develop high-quality software in an iterative or incremental

manner. However, it is possible to use an evolutionary process to emphasize flexibility, extensibility,
and speed of development. The challenge for software teams and their managers is to establish a
proper balance between these critical project and product parameters and customer satisfaction.