Coursify

Foundations of Software Engineering

What is Software Engineering?

30 mins

Explores the definition, history, and purpose of software engineering.

Learning Goals

  • State a concise definition of software engineering.
  • Explain why a disciplined approach is needed for software projects.
  • Compare software engineering with traditional engineering disciplines.
  • Identify historical milestones that shaped modern software engineering.
  • Summarize the impact of software engineering on society.

Software engineering is a discipline that sits at the intersection of computer science and engineering, focused on the systematic design, development, testing, and maintenance of software systems. The IEEE Standard 610.12 defines it as:

"The application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software; that is, the application of engineering to software."

This definition emphasizes three critical adjectives: systematic (methodical and organized), disciplined (following established principles), and quantifiable (measurable and verifiable). Unlike ad-hoc programming, software engineering treats the entire software lifecycle — from requirements specification through deployment and maintenance — as an engineering problem demanding rigor, process, and accountability .

At its core, software engineering is not merely writing code. It encompasses requirements engineering, software design, construction, testing, maintenance, configuration management, engineering management, and the processes that bind them all together. The Guide to the SWEBOK (now in Version 4.0, published October 2024) organizes this discipline into 18 distinct knowledge areas, from software architecture and security to engineering operations and DevOps .

Footnotes

  1. Cast Software — Software Engineering Definition — IEEE Standard 610.12 definition of software engineering. ↩

  2. University of Nevada, Reno — What Is Software Engineering — Overview of software engineering as a discipline, its lifecycle, and characteristics of high-quality software. ↩

  3. IEEE Computer Society — SWEBOK V4.0 — The Guide to the Software Engineering Body of Knowledge, Version 4.0 with 18 knowledge areas. ↩

Introduction to Software Engineering — Definition and Foundations

Why a Disciplined Approach Is Essential

The need for discipline in software engineering is not academic — it was forged in the crucible of real-world failures. The software crisis of the 1960s revealed what happens when software is built without engineering rigor: projects ran over budget by as much as 189%, delivered late, or were cancelled outright . The problem has not entirely vanished. According to the Standish Group's CHAOS 2020 report, only 31% of software projects succeed (on time, on budget, with full scope), while 50% are "challenged" and 19% fail completely .

Without a disciplined approach, teams face cascading problems:

ProblemConsequenceEngineering Solution
Unclear requirementsRework, scope creepRequirements engineering
No design blueprintArchitectural decaySoftware architecture & design
Ad-hoc codingIntegration failuresConstruction standards & code review
Inadequate testingDefective releasesSystematic test strategies
Poor change managementRegression bugsConfiguration management
No quality metricsUnpredictable outcomesQuantifiable measurement & process

A disciplined engineering approach transforms these risks into manageable challenges through predictability and quantifiable results achieved via theories, methodologies, frameworks, and tools . It means that when you build software, you can estimate effort, measure quality, and reproduce success — the hallmarks of any legitimate engineering discipline.

Footnotes

  1. Standish Group — 1994 CHAOS Report (PDF) — Original data showing 16.2% success, 52.7% challenged, 31.1% cancelled; 189% average cost overrun. ↩

  2. Faeth Coaching — IT Project Failure Rates (CHAOS 2020) — Summary of CHAOS 2020 report: 31% success, 50% challenged, 19% failure. ↩

  3. Cast Software — Software Engineering Definition — IEEE Standard 610.12 definition of software engineering. ↩

The Cost of Undisciplined Development

The 1994 CHAOS Report found that only 16.2% of projects succeeded, while 52.7% ran 189% over cost estimates and 31.1% were cancelled before completion. In 1995 alone, American companies and government agencies spent an estimated 81billiononcancelledsoftwareprojects.TheDenverairportbaggagesystemfailurealonecostthecity81 billion on cancelled software projects. The Denver airport baggage system failure alone cost the city 1.1 million per day. These are not abstract risks — they are the direct consequences of building software without engineering discipline.

Software Engineering vs. Traditional Engineering

The question "Is software engineering real engineering?" has been debated for decades . Both disciplines share fundamental engineering principles: they apply scientific and mathematical knowledge to design and build solutions that meet user needs, under constraints of cost, time, and quality. However, significant differences arise from the immaterial nature of software.

DimensionTraditional EngineeringSoftware Engineering
MaterialPhysical (steel, concrete, silicon)Abstract (code, data, logic)
Design vs. ConstructionDesign is cheap; construction is expensiveDesign (coding) is the primary cost; "construction" (copying) is nearly free
PrototypingExpensive — must build physical modelsCheap and routine — iterate rapidly
TestingMostly after physical completionContinuous and integrated throughout
Change CostVery high after constructionLower initially, but can increase if architecture is poor
MethodologiesTraditional project management (waterfall-like)Agile, iterative, DevOps
StandardsBuilding codes, safety regulations (e.g., ASCE, ASME)IEEE/ISO/IEC standards, SWEBOK
LicensingProfessional Engineer (PE) licensure requiredLicensure rare; certification voluntary
Failure ModeVisible, often physical (bridge collapse)Invisible, often logical (data corruption, security breach)

A crucial insight, argued by Jack Reeves in 1992, is that source code is the design in software engineering, and compilation/building is the "construction" phase — which is essentially free . This inverts the economic model of traditional engineering, where building the physical artifact is the dominant cost. This fundamental difference explains why iterative methodologies like Agile are so effective in software: it is cheap to redesign (refactor) in ways that would be prohibitively expensive for a bridge or building.

Footnotes

  1. Software Engineering Stack Exchange — Is Software Development an Engineering Discipline? — Discussion of Jack Reeves' argument that code is design and the economic differences between software and traditional engineering. ↩ ↩2 ↩3

  2. GeeksforGeeks — Software Engineering vs Conventional Engineering — Comparison table of software engineering and conventional engineering processes. ↩

  3. IEEE Computer Society — SWEBOK V4.0 — The Guide to the Software Engineering Body of Knowledge, Version 4.0 with 18 knowledge areas. ↩

Key Distinction: Code Is Design

In traditional engineering, blueprints are the design and building the physical structure is construction. In software, source code serves as the design artifact — the "construction" phase is simply compilation, which is essentially free. This means software can be redesigned continuously, but it also means design rigor (code quality, architecture) is even more critical since there is no separate construction phase to catch design flaws.

Historical Milestones That Shaped Modern Software Engineering

The Software Crisis

1960s

As computing hardware grew more powerful, software projects grew correspondingly complex — but methods to manage that complexity did not keep pace. Projects routinely exceeded budgets by 189%, missed deadlines, and produced unreliable systems. The term 'software crisis' encapsulated this growing recognition that software development was out of control."

NATO Conference on Software Engineering

1968

Held in Garmisch, Germany, this landmark conference brought together leading computer scientists to address the software crisis. The term 'software engineering' was deliberately chosen to suggest that software production should be treated with the same discipline as traditional engineering. Brian Randell and Peter Naur edited the influential proceedings, which became a founding document of the field."

Second NATO Conference (Rome)

1969

A follow-up conference in Rome focused on software engineering techniques. Edsger Dijkstra was notably the only participant to explicitly refer to a 'crisis.' The proceedings furthered the push for structured programming and formal methods, though some attendees like Brian Randell became disillusioned with how the term was being used."

Structured Programming Revolution

1968–1972

Dijkstra's advocacy for structured programming, including his famous 1968 letter 'Go To Statement Considered Harmful,' promoted the idea that software could be built with mathematical rigor. This era established that programming should follow logical structures (sequence, selection, iteration) rather than arbitrary jumps."

Waterfall Model Formalized

1970

Winston Royce published 'Managing the Development of Large Software Systems,' formalizing the waterfall model with sequential phases: requirements → design → implementation → testing → deployment. Though Royce himself advocated for iteration, the rigid interpretation became widely adopted in defense and aerospace."

Agile Movement Emerges

1995–2001

The Agile Manifesto (2001) was a reaction against heavyweight, plan-driven processes. Principles like valuing individuals over processes, working software over documentation, and responding to change over following a plan reshaped how teams build software. Scrum, XP, and other Agile frameworks gained rapid adoption."

SWEBOK Standardized (ISO/IEC 19759)

2005

The Guide to the Software Engineering Body of Knowledge was recognized as an ISO/IEC standard (TR 19759:2005), establishing an international consensus on the core knowledge areas of the discipline. It codified 10 knowledge areas initially, later expanded to 15 and then 18."

SWEBOK V4.0 Released

2024

The latest version of SWEBOK introduces three new knowledge areas — Software Architecture, Software Security, and Software Engineering Operations — and integrates modern practices including Agile, DevOps, AI, and IoT across all knowledge areas."

Software Project Outcomes Over Time (CHAÓS Report Data)

Percentage of projects categorized as successful, challenged, or failed

How Software Engineering Transforms Society

  1. 1
    Step 1

    Software adds over **1.07trillion∗∗annuallytotheUSGDPwhenincludingdirect,indirect,andinducedeffects,withthesoftwareindustrydirectlycontributing1.07 trillion** annually to the US GDP when including direct, indirect, and induced effects, with the software industry directly contributing 475.3 billion (2014 data). It supports nearly 10 million jobs nationwide — from developers to accountants to project managers — and invests $52 billion annually in R&D, representing 17.2% of all domestic business R&D in the US .

    Footnotes

    1. BSA — The Economic Impact of Software — Study finding software contributed 1.07trilliontoUSGDP,supported 10millionjobs,andinvested1.07 trillion to US GDP, supported ~10 million jobs, and invested 52 billion in R&D (2014 data). ↩

  2. 2
    Step 2

    Software is not confined to the tech sector. It enables productivity growth across every industry: healthcare (electronic health records, telemedicine), finance (algorithmic trading, mobile banking), manufacturing (CAD/CAM, supply chain optimization), agriculture (precision farming), and transportation (autonomous vehicles, logistics optimization).

  3. 3
    Step 3

    Software has fundamentally changed how humans communicate, learn, work, and govern. Social media platforms, educational technology, remote work tools, and e-government systems all rely on software engineering to function reliably at scale. The quality and security of these systems directly impacts democratic processes, public health outcomes, and education access.

  4. 4
    Step 4

    Modern life depends on software in safety-critical domains: avionics, medical devices, nuclear power plant controls, and autonomous vehicles. A single defect in such systems can have catastrophic consequences. The discipline of software engineering — including formal verification, rigorous testing, and safety standards — is what makes these systems trustworthy enough to deploy.

  5. 5
    Step 5

    Despite progress, challenges persist. Security vulnerabilities affect billions of devices annually. Algorithmic bias in AI systems raises ethical concerns. Digital divides limit access to software's benefits. And the environmental cost of running massive data centers is growing. These challenges underscore that software engineering is not just a technical discipline — it carries profound societal responsibility.

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. — IEEE Standard 610.12

Common Questions About Software Engineering

Knowledge Check

Question 1 of 5
Q1Single choice

According to the IEEE Standard 610.12, which three adjectives characterize the approach used in software engineering?

Next