Chapter 01 of 32

Introduction to Software Engineering

Think about the apps you used today: a UPI payment app, the IRCTC booking site, a food delivery app, your university result portal. Each of them was built by a team, is used by lakhs or crores of people, runs for years, and keeps changing every few weeks. Nobody builds something like that by sitting down and "just coding".

Writing a 100-line program for a lab assignment and building a payment system used by millions are very different jobs. The second one needs planning, teamwork, clear requirements, careful design, systematic testing and years of maintenance. The discipline that deals with all of this is called Software Engineering. In this chapter we will understand what software really is, what software engineering means, why we need it, how it differs from just programming, and what the rest of this tutorial will cover.


What Is Software?

Most students think software = code. That is only part of the story.

Software is a set of computer programs together with the associated data and documentation needed to install, use, operate and maintain them.

So a real software product includes:

  • Programs: the source code and the executable files built from it.

  • Data and configuration: database schemas, configuration files, default settings, test data.

  • Documentation: requirements documents, design documents, user manuals, API documentation, installation guides, release notes.

Why does this matter? Because when the original developer leaves the company, the people who maintain the software need the documentation and tests as much as the code. A program without documentation is much harder to change safely.

Two Broad Kinds of Software Products

Kind

Who decides the requirements

Examples

Generic (off-the-shelf) products

The developing company, based on what it thinks the market wants

Microsoft Word, Photoshop, Tally, a mobile game

Customized (bespoke) products

A specific customer, who pays for software built for their needs

A bank's core banking system, a hospital management system for one hospital, a government portal

The line is blurring: products such as ERP systems (for example SAP) are generic but are heavily configured for each customer.


What Is Software Engineering?

The phrase "software engineering" became popular after a NATO Software Engineering Conference held in Garmisch, Germany, in October 1968. The organisers chose the name on purpose, to suggest that building software should rest on the same kind of theory and disciplined practice that other engineering branches use. Around the same time, Margaret Hamilton, who led the team writing the on-board flight software for NASA's Apollo missions, also used the term to give software work the same respect as hardware engineering.

Two definitions are worth remembering:

IEEE definition (paraphrased): Software engineering is the application of a systematic, disciplined, quantifiable approach to the development, operation and maintenance of software, that is, the application of engineering to software.

Fritz Bauer (1968 NATO conference, paraphrased): Software engineering is the establishment and use of sound engineering principles to obtain, economically, software that is reliable and works efficiently on real machines.

Let us unpack the important words in the IEEE definition, because exam answers that explain them score well:

Word

Meaning in practice

Systematic

Work follows a defined process (requirements, then design, then construction, then testing...) instead of random coding.

Disciplined

The team follows agreed rules: coding standards, code reviews, version control, documentation, testing before release.

Quantifiable

Things are measured: size, effort, cost, schedule, defects, reliability. What is measured can be estimated and improved.

Development, operation and maintenance

Software engineering covers the whole life of the software, not only the first version.

A short way to remember it: software engineering is about building the right software, building it right, on time and within budget, and keeping it working as the world around it changes.


Why Do We Need Software Engineering?

If a single student can write a working program, why do companies need processes, documents and managers? Because several things change when software grows.

1. Size and Complexity

A lab program might be 200 lines. Large real systems (an operating system, a browser, a core banking system) contain millions of lines of code. No one person can hold all of it in their head. The work has to be divided among many people, and their pieces must fit together. That needs design, interfaces and coordination.

2. Cost

Software is expensive mainly because of human effort. Bad decisions early (for example, misunderstanding a requirement) become very costly to fix later, after design, code and tests have been built on top of them. A disciplined process catches mistakes early, when they are cheap.

3. Quality and Safety

Software now controls money, medical devices, aircraft, trains and power grids. A bug is not just an annoyance; it can lose crores of rupees or even lives. We will see real examples in the next chapter, Software Characteristics & Software Crisis.

4. Change

Requirements change, laws change (think of GST rules), platforms change (new Android versions), and users ask for new features. Software that is well structured and well documented can be changed safely; spaghetti code cannot.

5. Teamwork and Long Life

Successful software lives for many years, much longer than any one developer stays on the team. Clear processes and documentation let new people understand and continue the work.


Program vs Software Product

This comparison is a favourite short-answer question in university exams.

Aspect

Program (personal / toy)

Software product

Developed by

Usually one person

A team, often many teams

Users

Mostly the author

Many users who did not write it

Size

Small

Large

User interface

Minimal; the author knows how to use it

Carefully designed for non-expert users

Documentation

Little or none

Requirements, design, user manual, test reports

Testing

Informal, a few runs

Systematic, planned, at several levels

Process

Code-and-fix

Follows a defined life cycle

Lifetime

Short

Years; maintained and extended

The "Build and Fix" Style

Without any process, people fall into build and fix (also called code and fix or the exploratory style): write some code, run it, fix whatever breaks, repeat.

   +-------------+       +-----------+
   |  Write code | ----> |  Run it   |
   +-------------+       +-----------+
          ^                    |
          |   found a bug /    |
          |   new idea         v
          +-------------- [ Fix it ]

This works for a 100-line assignment. For anything large it fails, because:

  • There is no clear idea of what the finished product should do, so the team keeps changing direction.

  • Each fix tends to break something else, so the code becomes harder and harder to change.

  • Effort and time grow much faster than the size of the program.

  • Nobody can estimate when it will be finished.

Software engineering replaces this with a planned life cycle, which we study from the chapter Software Development Life Cycle (SDLC) onwards.


Software Engineering as a Layered Technology

Roger Pressman, author of one of the most used textbooks, describes software engineering as four layers, each resting on the one below:

   +---------------------------------------------+
   |                   Tools                     |   IDEs, Git, Jira, CI servers,
   +---------------------------------------------+   test frameworks
   |                  Methods                    |   how to do each task: requirements
   +---------------------------------------------+   analysis, design, coding, testing
   |                  Process                    |   the framework that holds it all
   +---------------------------------------------+   together: what to do, when, by whom
   |              A Quality Focus                |   the bedrock: commitment to quality
   +---------------------------------------------+
  • Quality focus: the foundation. Every engineering discipline must rest on a commitment to quality, and to continuous improvement.

  • Process: the glue. It defines the activities, the order they happen in, the work products (documents, code, models) and the milestones.

  • Methods: the technical "how to" for each activity, such as how to write use cases, how to design a module, how to choose test cases.

  • Tools: automated or semi-automated support for the process and methods. When tools are integrated so that information made by one is used by another, the older textbooks call it CASE (Computer-Aided Software Engineering).

A common exam trap: the bottom layer is the quality focus, not tools.


The Generic Process Framework

Whatever model a team follows, the same basic activities appear. Pressman names five framework activities:

  1. Communication: talk to the customer and stakeholders to understand objectives and gather requirements.

  2. Planning: create a plan: tasks, risks, resources, work products and schedule.

  3. Modeling: build models (analysis and design) to understand the problem and plan the solution.

  4. Construction: write code and test it.

  5. Deployment: deliver the software (complete or as an increment) to the customer, who evaluates it and gives feedback.

Running across all of these are umbrella activities, which continue throughout the project:

  • Project tracking and control

  • Risk management

  • Software quality assurance

  • Technical reviews

  • Measurement

  • Software configuration management (version control and change control)

  • Reusability management

  • Work product preparation and production (documents, models, logs)

Ian Sommerville, another standard textbook author, describes four fundamental activities instead: specification (what should the system do), development (design and implementation), validation (does it do what the customer wants) and evolution (changing it as needs change). The two lists describe the same work at different levels of detail.


What Makes Good Software?

Besides doing what it is supposed to do, good software has some essential qualities. Sommerville lists four:

Attribute

Meaning

Example

Maintainability

It can be changed easily as requirements change

Adding a new payment method to an app without rewriting checkout

Dependability and security

Reliable, safe, and resistant to attacks; failures should not cause damage

A banking app never credits money twice and cannot be hijacked

Efficiency

Does not waste processor time, memory, battery or network

A search returns in milliseconds; an app does not drain the phone

Acceptability

Understandable, usable and compatible with the systems its users already have

Works on common phones, in regional languages, with a clear interface

We will study quality in depth in Software Quality & Metrics and Software Reliability.


Field

Main concern

Computer science

Theory and fundamentals: algorithms, computation, data structures, languages. "What is possible and how efficiently?"

Software engineering

The practical, economical production of reliable software by teams. "How do we build and maintain useful software on time and within budget?"

Systems engineering

Whole systems made of hardware, software, people and processes (an aircraft, a railway signalling system). Software engineering is one part of it.

Programming

Writing code. It is one activity inside software engineering, alongside requirements, design, testing, project management and maintenance.


A Short History

Year

Milestone

1968

NATO Software Engineering Conference in Garmisch, Germany; the term "software crisis" is widely discussed

1970

Winston Royce's paper describing a sequential development process, later called the waterfall model

1975

Fred Brooks publishes The Mythical Man-Month, based on IBM's OS/360 experience

1981

Barry Boehm publishes Software Engineering Economics, introducing the COCOMO cost model

1986–1988

Boehm's spiral model, a risk-driven process model

1990s

Object-oriented methods, UML (adopted by OMG in 1997), Capability Maturity Model (CMM) for process improvement

2001

Manifesto for Agile Software Development

Around 2009 onwards

DevOps and continuous delivery become mainstream

2020

Latest edition of the Scrum Guide published

2024

SWEBOK Guide version 4.0 (IEEE Computer Society's Software Engineering Body of Knowledge), with 18 knowledge areas

Notice the general direction: from heavy, plan-everything-upfront processes towards shorter cycles, frequent delivery and automation. You will see that journey chapter by chapter in this tutorial.


Who Does What in a Software Project?

Role

Main responsibility

Customer / client / product owner

Decides what the software must do and what is most valuable

Business analyst

Gathers and documents requirements

Project manager

Plans, estimates, tracks schedule, cost and risks

Software architect

Makes high-level design decisions: components, technologies, interfaces

Developers

Design details, write code and unit tests

Testers / QA engineers

Plan and run tests, report defects

DevOps / operations engineers

Build pipelines, deploy, monitor production

End users

Use the software and give feedback

In agile teams some of these roles merge; for example Scrum defines just three accountabilities (Product Owner, Scrum Master and Developers). That comes later in Scrum.


What This Tutorial Covers

Foundations      : Introduction, Characteristics & Crisis, SDLC
Process models   : Waterfall, Iterative & Incremental, Prototyping,
                   Spiral, V-Model
Agile & modern   : Agile, Scrum, Kanban & XP, DevOps & CI/CD
Requirements     : Requirements Engineering, SRS, Feasibility Study
Project mgmt     : Project Management, LOC & Function Points, COCOMO,
                   Gantt/PERT/CPM, Risk Management
Design           : Design Principles, Coupling & Cohesion, UML, DFDs
Testing          : Fundamentals, Black-box, White-box, Levels of Testing
Quality & after  : Quality & Metrics, Reliability, Maintenance,
                   Configuration Management

Common Mistakes Students Make

  • Thinking software is only code. Documentation, data and configuration are part of software.

  • Thinking software engineering = coding. Coding is often a minority of the total effort; requirements, design, testing and maintenance take the rest.

  • Saying "tools" is the foundation layer. In Pressman's layered view, the foundation is the quality focus; tools sit on top.

  • Treating process as paperwork. A process exists to reduce risk and rework. Agile methods still have a process; it is just lighter and more iterative.

  • Ignoring maintenance. For long-lived software, the effort spent after the first release usually exceeds the effort to build the first version.


Interview / Exam Questions

1. Define software engineering.

Software engineering is the application of a systematic, disciplined and quantifiable approach to the development, operation and maintenance of software (IEEE). In simple terms, it applies engineering principles so that reliable software is built on time, within budget, and can be maintained.

2. Is software just a program? Explain.

No. Software is programs plus the associated data, configuration and documentation (requirements, design, user manuals, test plans) needed to install, operate and maintain it.

3. Why is "code and fix" unsuitable for large projects?

There is no clear specification or design, so changes break other parts, the code structure decays, progress cannot be measured or estimated, and cost grows much faster than size. Team coordination also becomes impossible without agreed interfaces and documents.

4. What are the layers of software engineering according to Pressman?

From bottom to top: a quality focus, process, methods and tools. The process layer holds the technology layers together; methods give the technical how-to; tools automate support for process and methods.

5. What are umbrella activities? Give examples.

Activities that run throughout the project rather than in one phase: project tracking and control, risk management, quality assurance, technical reviews, measurement, configuration management, reusability management and work product preparation.

6. Name four attributes of good software.

Maintainability, dependability and security, efficiency, and acceptability (usability and compatibility for its intended users).

7. When and where did the term "software engineering" become popular?

At the NATO Software Engineering Conference in Garmisch, Germany, in October 1968, which was called to discuss the problems of building large software reliably (the "software crisis").


Summary

  • Software = programs + data/configuration + documentation.

  • Software engineering is a systematic, disciplined, quantifiable approach to developing, operating and maintaining software.

  • We need it because of size, cost, quality and safety demands, constant change and long-lived team projects.

  • A program is a small personal artifact; a software product is large, documented, tested, used by others and maintained for years.

  • Pressman's layers: quality focus → process → methods → tools.

  • Generic framework activities: communication, planning, modeling, construction, deployment, plus umbrella activities across all of them.

  • Good software is maintainable, dependable and secure, efficient and acceptable.

In the next chapter, Software Characteristics & Software Crisis, we will see what makes software so different from physical products, and why so many software projects failed before (and even after) software engineering was born.