1

SOFTWARE ENGINEERING

UNIT 1:

Chapter-1 Introduction: Evolution, Software development projects, Exploratory style

of software developments, Emergence of software engineering, Notable changes in
software development practices, Computer system engineering.

Chapter-2 Software Life Cycle Models: Basic concepts, Waterfall model and its
extensions, Rapid application development, Agile development model, Spiral model.

Introduction:

What is software engineering ? :

​ A popular definition of software engineering is: “A systematic collection of

good program development practices and techniques . Good program development
techniques have resulted from research innovations as well as from the lessons learnt
by programmers through years of programming experiences. An alternative definition of
software engineering is: “An engineering approach to develop software”. Software
engineering discusses systematic and cost-effective techniques for software
development. These techniques help develop software using an engineering approach.

❖​ 1.1 Evolution of Software Engineering

➢​ 1.1.1. Evolution of an Art into an Engineering Discipline
➢​ 1.1.2. Evolution Pattern for Engineering Disciplines
➢​ 1.1.3. A Solution to the Software Crisis

1.1.1. Evolution of an Art into an Engineering Discipline

●​ Software development initially relied on an exploratory, "build and fix" approach,

where programmers wrote code without formal design or planning.
●​ Early programmers relied on personal intuition and experience, often developing
unique techniques for coding.
 2

●​ Over time, software development evolved into a structured process, incorporating

systematic principles and methodologies.

1.1.2. Evolution Pattern for Engineering Disciplines

●​ Similar to other fields like iron-making and civil engineering, software engineering
transitioned through three stages:
1.​ Art: A few individuals possessed specialized knowledge, often kept as a
secret.
2.​ Craft: Knowledge was shared among apprentices and improved through
practice.
3.​ Engineering Discipline: Standardized principles and scientific methods
were applied for systematic development.
●​ This transition allowed for better predictability, efficiency, and maintainability in
software development.

1.1.3. A Solution to the Software Crisis

●​ The "software crisis" refers to increasing software development costs, poor

reliability, maintenance difficulties, and frequent project failures.
 3

●​ Organizations now spend more on software than hardware, making cost-effective

software engineering practices essential.
●​ Adopting software engineering techniques helps develop high-quality software
efficiently, reducing costs and improving reliability​

❖​ 1.2. Software Development Projects

➢​ 1.2.1. Types of Software Development Projects.
➢​ 1.2.2. Software Projects Being Undertaken by Indian Companies

1.2.1.Types of Software Development Projects.

→ This section discusses different types of software development projects and how
professional software differs from toy programs written by students or hobbyists.

Programs vs. Products

Software can be categorized based on purpose, user base, and complexity.

●​ Programs (Toy Software):​

○​ Created by students or hobbyists for learning or personal use.

○​ Typically small, lack user-friendly interfaces, documentation, and
maintainability.
○​ The same person who writes the code usually maintains it.
●​ Products (Professional Software):​
 4

○​ Developed for multiple users and commercial use.

○​ Comes with user-friendly interfaces, documentation, and manuals.
○​ Created by teams using structured development methodologies.
○​ Requires planning, testing, and systematic development.

Even though software engineering principles are primarily intended for professional
software, small programs can also benefit from them.

→ Types of Software Development Projects

Software development projects can be classified into two major categories:

1.​ Software Products

○​ These are generic software solutions developed for a broad user base and
sold commercially.
○​ Examples: Microsoft Windows, Oracle DBMS, Adobe Photoshop.
○​ Companies identify features useful to a wide audience and define product
specifications accordingly.
○​ Some companies develop product lines that target slightly different
market segments, e.g., Windows for desktops vs. Windows Server for
enterprises.
2.​ Software Services
○​ These involve developing customized solutions or working on outsourced
projects.
○​ Custom Software Development:
■​ Tailored for a specific client based on their unique requirements.
■​ Example: An academic institution’s student management system.
■​ Companies modify existing software to fit the client’s needs, reusing
previous code wherever possible.
○​ Outsourced Software Development:
■​ Some companies subcontract specific parts of their projects to
others.
■​ Reasons for outsourcing:
■​ Lack of expertise in a particular domain.
■​ Cost-effectiveness of outsourcing to companies with
specialized skills.
■​ These projects are typically small and must be completed within a
short period.

The type of projects a company takes on affects its profitability and business risk:
 5

●​ Product development provides long-term revenue but requires high upfront

investment.
●​ Outsourcing projects generate immediate revenue but do not provide long-term
financial returns.

1.2.2 Software Projects in India

●​ Indian IT companies have excelled in software services, becoming global

leaders in outsourcing.
●​ Indian firms have been slow to develop software products due to the high
financial risks involved.
●​ Recently, Indian companies have begun focusing on product development,
contributing to the global software market.
●​ The software services sector is expanding rapidly, driven by advancements
in:
○​ Cloud computing
○​ Application service provisioning (ASP)

India’s IT industry is evolving from outsourced service providers to product

innovators, though software services continue to dominate​

❖​1.3. Exploratory Style of Software Development.

➢​ 1.3.1. Perceived Problem Complexity: An Interpretation Based on Human
Cognition Mechanism
➢​ 1.3.2.Principles Deployed by Software Engineering to Overcome Human
Cognitive Limitations

1.3. Exploratory Style of Software Development

●​ Exploratory Style of Software Development refers to an informal development

style or build and fix style , in which the programmer uses his own intuition to
develop a program rather than making use of systematic body of knowledge
which is categorised under the software engineering discipline.
●​ This style of development gives complete freedom to programmers
●​ This dirty program is quickly developed and have high flexibility
●​ It is used where requirements are not specified or the requirements are changing
time to time
 6

●​ This style does not offer any rules to start developing software . Bugs are fixed
whenever they raises

→ Steps involved in Exploratory Style of Software Development.

●​ Though the exploratory style imposes no rules, a typical development

starts after an initial briefing from the customer.
●​ Based on this briefing, the developers start coding to develop a working
program.
●​ The software is tested and the bugs found are fixed.
●​ This cycle of testing and bug fixing continues till the software works
satisfactorily for the customer.
●​ A schematic of this work sequence in a build and fix style has been shown
graphically in Figure 1.3.
●​ Observe that coding starts after an initial customer briefing about what is
required. After the program development is complete, a test and fix cycle
continues till the program becomes acceptable to the customer.

→ Characteristics of the Exploratory Style

●​ No structured development process – The programmer starts coding based on a
brief discussion with the customer.
●​ Frequent testing and bug-fixing – After coding, the software is tested, and any
detected issues are fixed in multiple iterations.
●​ Customer-driven acceptance – The cycle of coding, testing, and fixing continues
until the customer is satisfied
 7

→Problems with the Exploratory Style

●​ Exponential growth in effort and time: As software size increases,
development effort and time rise exponentially, making large-scale projects
infeasible​.
●​ Poor code maintainability: Since there is no formal design, the resulting code is
often unstructured and difficult to modify.
●​ Not suitable for team development:
○​ Without proper design and documentation, it is hard to divide work among
multiple developers.
○​ Most modern software projects require team collaboration, making this
approach impractical​

1.3.1: Perceived Problem Complexity

The perceived problem complexity in software development is based on human

cognitive limitations. As the problem size increases, the perceived difficulty grows
exponentially, making it harder to solve using an exploratory approach​.

Human Cognition and Complexity Growth

●​ The human brain has a limited short-term memory, which can hold around 7
± 2 items at a time.
 8

●​ When problem size increases, the number of elements to track exceeds the
brain’s capacity, making it difficult to manage complexity.
●​ This explains why exploratory development leads to exponentially
increasing effort and time as software grows larger​.

Impact on Software Development

●​ Small programs (1,000–2,000 lines) are within a manageable range.

●​ Large programs (millions of lines) become impractical without structured
methods, as tracking all details manually is nearly impossible.
●​ The lack of design, documentation, and planning in exploratory development
results in inefficient workflows​

1.3.2: Principles Deployed by Software Engineering

To overcome human cognitive limitations, software engineering relies on two key

principles:

1.​ Abstraction (Modeling)​

○​ Simplifies complex problems by focusing on key aspects and ignoring

details.
○​ Example: A map represents a country without showing every house, tree,
or person.
 9

○​ Helps programmers manage complexity by breaking down problems into

essential components​.

2.​ Decomposition (Divide and Conquer)​

○​ Breaks a large problem into smaller, manageable parts.

○​ Example: A book is divided into chapters, sections, and subsections,
making it easier to understand.
○​ Ensures that different team members can work on separate parts
efficiently​

❖​ 1.4.Emergence of Software Engineering

➢​ 1.4.1.Early Computer Programming.
➢​ 1.4.2.High-level Language Programming.
➢​ 1.4.3.Control Flow-based Design.
➢​ 1.4.4.Data Structure-oriented Design.
➢​ 1.4.5.Data Flow-oriented Design.
➢​ 1.4.6.Object-oriented Design.
➢​ 1.4.7.What Next?.
➢​ 1.4.8.Other Developments..
 10

1.4.1 Early Computer Programming

●​ Early commercial computers were slow and primitive, limiting the complexity of
programs.
●​ Programs were written in assembly languages, typically consisting of a few
hundred lines of monolithic code.
●​ Programmers followed an ad hoc, build-and-fix approach, writing code based on
intuition without planning or design.
●​ Issues:
○​ Poor maintainability.
○​ High effort required for debugging and modifications.
○​ Limited program size and functionality​.

1.4.2 High-Level Language Programming

 11

●​ In the 1960s, computers became faster due to the introduction of semiconductor

technology (transistors replacing vacuum tubes).
●​ High-level languages like FORTRAN, ALGOL, and COBOL were introduced.
●​ Benefits of high-level languages:
○​ Allowed larger programs to be written.
○​ Reduced the complexity of programming by abstracting machine-level
details.
○​ Increased programmer productivity.
●​ However, the exploratory (build-and-fix) approach was still dominant, limiting
software scalability​.

1.4.3 Control Flow-Based Design

●​ As software complexity increased, the exploratory style became inefficient and

unmanageable.
●​ Control flow-based design was introduced to improve program structure.
●​ Flowcharting techniques helped visualize the sequence of operations in a
program.
●​ Benefits:
○​ Improved readability and maintainability of programs.
○​ Helped programmers design efficient control structures.
●​ Despite these improvements, software projects remained difficult to scale and
modify​.

1.4.4 Data Structure-Oriented Design

●​ With the rise of integrated circuits (ICs) in the 1970s, software needed to handle
larger and more complex problems.
●​ Focus shifted from control flow to data structure-oriented design.
●​ Key idea: First design the data structures, then build program logic around them.
●​ Example methodology:
○​ Jackson Structured Programming (JSP) – First design the data structure,
then derive the program logic.
●​ Benefits:
○​ Allowed better organization of large software projects.
○​ Facilitated code reuse and modularization.
●​ Limitations:
○​ Still not suitable for large-scale software projects.
○​ Lacked a systematic approach to manage complex data interactions​.

1.4.5 Data Flow-Oriented Design

 12

●​ As computers became faster with VLSI (Very Large Scale Integration) circuits,
more sophisticated software was needed.
●​ Data flow-oriented design introduced the idea of tracking data movement instead
of just focusing on control flow.
●​ Key Concept:
○​ Identify major data items and determine the processing required to
transform them into the desired output.
○​ Represent data interactions using Data Flow Diagrams (DFDs).
●​ Example:
○​ A car assembly plant can be modeled using a DFD, where each
workstation represents a process that modifies data (similar to a function
in software).
●​ Advantages of DFDs:
○​ Simple and easy to understand.
○​ Can be applied to both software and real-world processes.
○​ Helps in breaking down complex systems into smaller modules.
●​ This approach laid the foundation for structured software design methodologies​.

1.4.6 Object-Oriented Design (OOD)

●​ In the late 1970s, Object-Oriented Design (OOD) emerged as an improvement

over data flow-based design.
●​ Key Idea:
○​ Identify objects relevant to the problem domain (e.g., "Employee,"
"Payroll").
○​ Define relationships between objects (e.g., inheritance, association,
composition).
○​ Each object contains data and methods, enforcing data hiding and
abstraction.
 13

●​ Advantages of OOD:
○​ Better modularity – Code is divided into independent objects.
○​ Reusability – Objects and classes can be reused across projects.
○​ Easier maintenance – Code modifications are localized to specific objects.
○​ Faster development – Encourages code reuse and reduces redundancy.
●​ Languages like C++, Java, and Python popularized OOD and made it the
dominant paradigm for modern software development​.

1.4.7 What Next?

●​ Software engineering continues to evolve with new paradigms and technologies.

●​ Emerging trends:
○​ AI-driven development – Automating parts of software design and coding.
○​ Agile methodologies – Iterative, customer-driven development.
○​ Cloud computing – Software as a service (SaaS) and distributed
computing.
○​ DevOps – Continuous integration and deployment to improve software
delivery speed​.

1.4.8 Other Developments

●​ Software engineering has introduced several innovations to improve efficiency

and quality:
○​ Software life cycle models (Waterfall, Agile, etc.).
○​ Quality assurance and testing techniques.
○​ Project management tools for handling large teams.
○​ Computer-Aided Software Engineering (CASE) tools to automate design
and coding

1.5.Notable Changes in Software Development Practices.

This section highlights the major differences between exploratory software
development and modern software engineering practices
→Key Differences Between Old and Modern Software Development Approaches
1.​ Error Correction vs. Error Prevention:
●​ Exploratory Development:
○​ Follows a build-and-fix model, where errors are fixed after they occur.
○​ Errors are usually detected only during final testing, making corrections
costly.
●​ Modern Software Engineering:
 14

○​ Focuses on error prevention, aiming to detect and resolve issues early

in development.
○​ Software is developed in structured phases like requirements
specification, design, coding, and testing.
○​ Errors are fixed in the same phase they are introduced, reducing
overall costs​
2.​ Coding-Centric vs. Process-Oriented Development :
●​ Exploratory Development:
○​ Views coding as the main development activity.
○​ Programmers often start coding immediately, modifying the program
until it works.
●​ Modern Software Engineering:
○​ Coding is only one part of software development.
○​ More effort is allocated to design, testing, and requirement analysis.
○​ Ensures that modifications are easier and cost-effective​.
3.​ Lack of Requirements vs. Clear Specification:
●​ Exploratory Development:
○​ Developers often start without a clear understanding of the problem.
○​ Requirements emerge gradually through trial and error.
●​ Modern Software Engineering:
○​ A well-defined requirements specification is prepared before
development starts.
○​ A clear specification reduces ambiguities and future changes, leading to
more efficient development​.
4.​ Ad-hoc Development vs. Structured Lifecycle Models:
●​ Exploratory Development:
○​ No formal development methodology is followed.
○​ Results in hard-to-maintain software that becomes increasingly complex
over time.
●​ Modern Software Engineering:
○​ Follows software life cycle models (Waterfall, Agile, etc.), ensuring
systematic progress.
○​ Helps manage large-scale projects effectively​

1.6 Computer Systems Engineering

 15

Computer Systems Engineering focuses on developing integrated systems that require

both hardware and software components. Unlike general software that runs on standard
computing platforms like desktops or servers, some applications necessitate specialized
hardware to function properly.

Examples of Such Systems:

●​ Robots - Require specialized processors and control systems.

●​ Factory Automation Systems - Use dedicated hardware and software for
industrial operations.
●​ Cell Phones - Have unique processors, speakers, and microphones, designed for
specific applications.

Hardware-Software Partitioning:

One key decision in systems engineering is determining which parts of a system should
be implemented in hardware and which in software. Several trade-offs are considered:

●​ Speed - Hardware is generally faster than software for specific tasks.

●​ Flexibility - Software is easier to modify and extend.
●​ Complexity - Complex functions are harder to implement in hardware.
●​ Cost and Power - Hardware solutions require extra space, increase
manufacturing costs, and consume more power.
 16

Concurrent Development and Testing:

Since hardware and software are developed simultaneously, testing becomes

challenging. The actual hardware may not be ready when software testing needs to
begin. To solve this issue, simulators are used to mimic hardware behavior during
software development.

After both components are built, they are integrated and tested together. Project
management is crucial throughout the entire process to ensure efficient coordination
between hardware and software teams.

Summary of Chapter 1

This chapter introduced software engineering as a discipline and traced its evolution
from an intuitive art to a structured engineering approach.

Key Points:

1.​ Software Crisis & Evolution​

○​ Early programming followed an exploratory, trial-and-error approach.

○​ The need for structured, reliable, and cost-effective development led to the
emergence of software engineering principles.
2.​ Software Development Projects​

○​ Various types of software projects exist, including application software,

system software, and embedded systems.
○​ Indian software companies have been significant contributors to global
software development.
3.​ Challenges in Software Development​

○​ The complexity of software projects increases non-linearly with size.

○​ Engineers use abstraction (simplifying systems into models) and
decomposition (breaking down problems into smaller parts) to manage
complexity.
4.​ Software Engineering Design Approaches​

○​ Programming evolved from basic structured programming to advanced

paradigms like data flow-oriented design and object-oriented design.
 17

○​ Each design methodology improved software maintainability and

efficiency.
5.​ Modern Software Development Practices​

○​ Standardized development models ensure efficient software engineering

processes.
○​ Practices like systematic testing, phase containment of errors, and
documentation have improved software quality and visibility.
6.​ Computer Systems Engineering​

○​ Unlike traditional software development, some projects require custom

hardware to support specific software.
○​ The field balances cost, flexibility, and performance by carefully deciding
what to implement in hardware versus software.