A car, a bridge and a mobile phone are physical things. You can touch them, they are produced in factories, and they slowly wear out. Software is none of these. You cannot see it, copying it costs almost nothing, and it never rusts, yet old software still "rots" and fails.
These unusual properties are exactly why building software turned out to be so hard. In the late 1960s the industry openly admitted it was in a software crisis: projects were late, over budget and full of bugs. In this chapter we study the characteristics that make software different from hardware, the famous failure curves, the main application domains, the software crisis with real-world disasters, and the common software myths that still cause trouble today. It builds directly on Introduction to Software Engineering.
Characteristics of Software
Pressman highlights three characteristics that set software apart from hardware. Most other textbooks add a few more. Let us go through them one by one and understand why each matters.
1. Software Is Developed or Engineered, Not Manufactured
For hardware, a large part of the cost is in manufacturing: every new phone needs material, a factory line and labour. Quality problems can be introduced during manufacturing.
For software, the cost is almost entirely in development (thinking, designing, coding, testing). Once built, making one more copy of an app costs practically nothing. There is no "manufacturing defect" in the usual sense: if a copy of an app has a bug, every copy has the same bug, because the bug is in the design.
Consequence: software projects cannot be managed like a factory production line. Estimation, planning and quality control focus on people and the development process, not on raw materials.
2. Software Does Not Wear Out, But It Does Deteriorate
Hardware failure rate over time follows the well-known bathtub curve:
Failure
rate
^
|\ /
| \ infant / wear out
| \ mortality / (dust, heat,
| \ / vibration, age)
| \_________________________________/
| useful life (low, steady)
+------------------------------------------------> Time
HARDWARE: the "bathtub curve"
Infant mortality: early failures from design or manufacturing defects.
Useful life: low, roughly constant failure rate.
Wear out: physical parts degrade, so failures rise again.
Software has no physical parts to wear out. In theory its failure curve would drop after early bugs are fixed and stay flat forever (the idealized curve). In practice, software is constantly changed: new features, bug fixes, platform updates. Each change can introduce new defects, causing a spike. Before the curve settles back down, another change arrives. Slowly the minimum failure rate creeps upward (the actual curve):
Failure
rate change change change
^ | | |
|\ v v v
| \ /\ /\ /\
| \ / \ / \ / \ _ _ actual curve
| \ / \ / \ / \/ (minimum rises)
| \ / \__/ \__/
| \_________/
| - - - - - - - - - - - - - - - - - - - - idealized curve
+---------------------------------------------------> Time
SOFTWARE: idealized vs actual failure curve
Key idea: software does not wear out; it deteriorates due to change. Every modification risks adding defects and making the structure messier. This is why maintainability and careful change management are so important.
Also, a worn hardware part can be replaced with an identical spare. There is no "spare part" for a software defect: fixing it means changing the design (the code) itself, which is more complex than swapping a component.
3. Most Software Was Custom-Built (Moving Towards Component Reuse)
Hardware engineers build from standard, catalogued components: screws, chips, resistors. Historically, much software was written from scratch for each project. Today this is changing quickly: developers reuse open-source libraries, frameworks (Spring, React, Django), package managers (npm, pip, Maven) and cloud services. Reuse saves effort, but it also brings new risks such as security holes in third-party packages.
Other Important Characteristics
Characteristic | What it means | Why it makes engineering harder |
|---|---|---|
Intangible (invisible) | You cannot see or touch software; progress is hard to observe | "90% done" is hard to verify; managers need metrics and demos |
Complex | A large program has a huge number of possible states and interactions | Exhaustive testing is impossible; designers must manage complexity with modularity |
Flexible / malleable | It seems easy to change: "just edit the code" | Customers request frequent changes, and each change can damage the structure |
Conformity | Software must fit whatever interfaces, laws and hardware already exist | Much complexity is forced from outside and cannot be designed away |
Cheap to copy | Reproduction costs almost nothing | All cost is in development; a bug is copied to every user |
Labour intensive | Built by people, not machines | Productivity varies widely between people; adding people does not scale linearly |
In his 1986 essay No Silver Bullet, Fred Brooks argued that four properties are essential to software (not accidents of today's tools): complexity, conformity, changeability and invisibility. Because they are essential, he predicted that no single technology would make software development dramatically easier, an argument that is still widely discussed.
Software Application Domains
Software is everywhere, but the main categories (following Pressman) are:
Domain | Description | Examples |
|---|---|---|
System software | Serves other programs; works closely with hardware | Operating systems, compilers, device drivers |
Application software | Stand-alone programs that solve a specific business need | Payroll, billing, inventory, hotel booking |
Engineering / scientific software | Numerical computation, simulation, modelling | Weather prediction, CAD, MATLAB, circuit simulators |
Embedded software | Lives inside a product and controls it | Washing machine controller, car ABS, pacemaker, smart meter |
Product-line software | Reusable products with configurable variants for many customers | Word processors, spreadsheets, ERP suites |
Web and mobile applications | Network-centric apps used through a browser or phone | Online banking, e-commerce, social media apps |
Artificial intelligence software | Uses non-numerical or learning-based algorithms | Recommendation engines, speech recognition, chatbots |
Legacy Software
Legacy software is older software that is still critical to the business, often written decades ago with outdated technology (for example COBOL on mainframes in banks and insurance companies). It is risky to replace but expensive to keep. It often has poor documentation and fragile structure. We return to this in Software Maintenance & Reengineering.
The Software Crisis
Software crisis is the name given (from the late 1960s) to the persistent inability of the industry to deliver software that is on time, within budget, of acceptable quality and meets user requirements, especially as programs became larger and more complex.
The term was discussed openly at the 1968 NATO conference. Edsger Dijkstra described the root of it well in his 1972 Turing Award lecture, The Humble Programmer: in his words (paraphrased), when there were no machines, programming was no problem; when there were a few weak computers it became a mild problem; and once there were gigantic computers, programming became an equally gigantic problem. Hardware power grew enormously, and the size of the software people tried to write grew with it, faster than the methods for writing it.
Symptoms of the Software Crisis
Projects running over budget and behind schedule.
Software that is unreliable and full of defects.
Software that does not meet user requirements, even after delivery.
Software that is hard to maintain and modify.
Projects cancelled after large amounts of money had been spent.
Inefficient use of hardware and poor productivity of developers.
Demand for software growing faster than the ability to produce it.
Causes
Growing size and complexity of systems, far beyond what one person can understand.
Poor requirements: vague, incomplete or constantly changing.
Poor estimation and planning: no reliable way to predict effort.
Lack of a disciplined process; reliance on code-and-fix.
Weak testing and late discovery of errors.
Poor communication between customers, managers and developers.
Insufficient training and rapid technology change.
The Mythical Man-Month
Fred Brooks managed IBM's huge OS/360 project in the 1960s. In The Mythical Man-Month (1975) he stated what is now called Brooks's law:
Brooks's law: adding manpower to a late software project makes it later.
Why? New people need time to learn the system (and experienced people must stop to teach them), and the number of communication paths grows rapidly with team size. With n people, the number of possible pairs who may need to talk is n(n − 1)/2:
Team size n Communication paths n(n-1)/2
3 3
5 10
10 45
20 190
Doubling the team from 10 to 20 does not double the coordination work; it more than quadruples the number of paths (45 → 190). This is one reason teams in Scrum are kept small.
Famous Software Failures
These real incidents show that the crisis is not only history. Each one teaches a software engineering lesson.
Therac-25 Radiation Machine (1985–1987)
A computer-controlled radiation therapy machine gave massive overdoses to patients in six known accidents; some of these patients died from their injuries. The earlier models had hardware safety interlocks; the Therac-25 relied on software alone. A race condition triggered when an operator edited the treatment settings quickly could leave the machine in a dangerous state. Investigators (notably Nancy Leveson and Clark Turner) also found poor testing, reused code from older models, and cryptic error messages that operators learned to ignore.
Lesson: safety-critical software needs independent safety analysis, rigorous testing and defence in depth, not blind trust in reused code.
Patriot Missile at Dhahran (1991)
During the Gulf War, a Patriot battery failed to intercept an incoming Scud missile, which hit a US Army barracks and killed 28 soldiers. The system counted time in tenths of a second, and 0.1 cannot be represented exactly in binary. The value was chopped to fit a 24-bit register, giving an error of about 0.000000095 seconds per tick. The battery had been running for about 100 hours:
ticks in 100 hours = 100 × 3600 × 10 = 3,600,000
error per tick ≈ 0.000000095 s (9.54 × 10^-8)
total clock drift ≈ 3,600,000 × 9.54 × 10^-8 ≈ 0.343 s
Scud speed ≈ 1676 m/s
distance in 0.343 s ≈ 575 m
A third of a second is enough for a Scud to travel more than half a kilometre, so the system looked in the wrong place and did not track the missile. The US General Accounting Office (GAO) report on the incident put the time error at about 0.34 seconds after 100 hours.
Lesson: numerical precision, assumptions about operating conditions (the system was not expected to run 100 hours non-stop) and timely deployment of fixes all matter.
Ariane 5 Flight 501 (4 June 1996)
About 37 seconds after launch, Europe's new Ariane 5 rocket veered off course and was destroyed. The inertial reference software, reused from Ariane 4, converted a 64-bit floating-point value to a 16-bit signed integer. Ariane 5 flew a faster trajectory, the value exceeded the 16-bit range, and the conversion raised an unhandled exception. The backup unit ran the same software and had already failed the same way.
Lesson: reused software must be re-verified against the new requirements and environment; identical redundancy does not protect against design errors.
Mars Climate Orbiter (1999)
NASA lost a Mars spacecraft because one team's ground software produced impulse values in pound-force seconds while the navigation software expected newton-seconds. The small, repeated error put the spacecraft on a fatally low trajectory.
Lesson: interfaces between teams must be precisely specified and checked; integration testing must cover them.
Knight Capital (2012)
A US trading firm lost about 440 million US dollars in roughly 45 minutes. During a deployment, new code was not copied to one of its servers, and a reused configuration flag woke up old, unused code on that server, which sent huge numbers of unintended orders.
Lesson: deployment is part of engineering. Automated, repeatable deployment and removal of dead code (topics of DevOps & CI/CD and Software Configuration Management) are essential.
CrowdStrike Outage (2024)
In July 2024, a faulty content update for the CrowdStrike Falcon security sensor caused Windows machines to crash. Microsoft estimated that about 8.5 million devices were affected, disrupting airlines, banks and hospitals worldwide, including flight check-ins at Indian airports.
Lesson: even small updates need testing and staged (gradual) rollout, because one bad change can reach millions of machines in minutes.
How Common Is Project Failure?
The Standish Group's 1994 CHAOS report, one of the most quoted surveys, classified only about 16% of the IT projects it studied as successful (on time, on budget, with all features). About 53% were "challenged" (late, over budget or with fewer features) and about 31% were cancelled. Researchers have criticised the report's methods, and later editions show improvement, but the numbers captured how serious the problem was.
How Software Engineering Responds to the Crisis
Problem | Software engineering response | Covered in |
|---|---|---|
No clear process | Defined life cycle models | SDLC, Waterfall, Iterative, Spiral, Agile |
Vague requirements | Requirements engineering and a signed-off SRS; frequent customer feedback | Requirements Engineering, SRS, Prototyping |
Bad estimates | Size and cost models, scheduling | Function Points, COCOMO, PERT & CPM |
Unexpected disasters | Explicit risk identification and mitigation | Risk Management, Spiral Model |
Unmaintainable code | Modular design, low coupling, high cohesion | Design Principles, Coupling & Cohesion |
Bugs found too late | Systematic testing at every level, reviews | Testing chapters |
Risky releases | Automation, version control, continuous integration | DevOps & CI/CD, Configuration Management |
Has the crisis ended? Not completely. Projects still fail, but the industry now has far better tools, processes and knowledge. Many people prefer to call it a "chronic affliction" rather than a crisis: a long-term condition we manage rather than a single emergency.
Software Myths
Pressman describes beliefs about software that sound reasonable but are wrong. Exams often ask for examples in three groups.
Management Myths
Myth | Reality |
|---|---|
"We already have a book of standards and procedures. That is enough." | Is it actually used, up to date, and suited to modern practice? Often it just sits on a shelf. |
"If we fall behind schedule, we can add more programmers and catch up." | Brooks's law: adding people to a late project makes it later, because of training and communication overhead. |
"If we outsource the project, we can relax." | An organisation that cannot manage software internally will struggle to manage an outsourced project too. |
Customer Myths
Myth | Reality |
|---|---|
"A general statement of objectives is enough to start coding; details can come later." | Ambiguous objectives are a recipe for disaster. Clear requirements (developed with continuous communication) are needed. |
"Requirements keep changing, but software is flexible, so changes are easy." | The cost of a change grows the later it is made. A change after design or release can require rework across the whole system. |
Practitioner (Developer) Myths
Myth | Reality |
|---|---|
"Once the program works, our job is done." | Most of the effort on a long-lived product is spent after first delivery, on maintenance and evolution. |
"Until the program runs, I cannot assess its quality." | Technical reviews of requirements, design and code find many defects before anything runs, and cheaply. |
"The only deliverable is the working program." | Models, documents, tests and plans are also deliverables; they guide support and maintenance. |
"Software engineering creates useless documentation and slows us down." | It is about quality. Better quality means less rework, and less rework means faster delivery. |
Common Mistakes Students Make
Saying "software wears out". It does not wear out; it deteriorates because of changes.
Drawing the bathtub curve for software. The bathtub curve is for hardware. Software has the idealized curve and the actual curve with spikes after each change.
Thinking the crisis was only about bugs. It was equally about cost overruns, delays, unmet requirements and unmaintainable code.
Misquoting Brooks's law as "more people means faster". It says the opposite for a late project.
Blaming Ariane 5 on "a typo". It was a reuse and verification failure: valid Ariane 4 assumptions were not re-checked for Ariane 5.
Interview / Exam Questions
1. "Software does not wear out." Explain with the failure curves.
Hardware follows the bathtub curve: high early failures, a low steady period, then rising failures as physical parts wear out. Software has no physical wear, so its idealized curve flattens after initial defects are fixed. In reality each change introduces new defects, producing spikes, and the minimum failure rate gradually rises. So software deteriorates due to change rather than wearing out.
2. What is the software crisis? List its symptoms.
The persistent difficulty, recognised from the late 1960s, of producing large software on time, within budget, reliably and meeting user needs. Symptoms: cost and schedule overruns, unreliable software, unmet requirements, hard-to-maintain code, cancelled projects and low productivity.
3. State Brooks's law and explain why it holds.
"Adding manpower to a late software project makes it later." New members need ramp-up time and take experienced members' time to train them, and communication paths grow as n(n − 1)/2, so coordination overhead rises faster than team size.
4. How many communication paths exist in a team of 8 developers?
8 × 7 / 2 = 28 paths.
5. What caused the Ariane 5 Flight 501 failure, and what is the software engineering lesson?
Reused Ariane 4 inertial reference software converted a 64-bit float to a 16-bit signed integer; on Ariane 5's faster trajectory the value overflowed, raising an unhandled exception in both (identical) units. Lesson: reused components must be re-verified for the new requirements and environment, and identical redundancy does not protect against design faults.
6. Give one management myth and one practitioner myth.
Management: "If we are behind schedule, we can add more programmers to catch up" (false by Brooks's law). Practitioner: "Once the program works, my job is done" (most effort goes into maintenance after delivery).
7. What are Brooks's four essential difficulties of software?
Complexity, conformity, changeability and invisibility (from No Silver Bullet, 1986).
Summary
Software is developed, not manufactured; its cost is in engineering, and copies are free.
Software does not wear out but deteriorates due to change (idealized vs actual curve); hardware follows the bathtub curve.
Software is intangible, complex, malleable and must conform to its environment; reuse of components is growing.
Major domains: system, application, engineering/scientific, embedded, product-line, web/mobile and AI software.
The software crisis means late, costly, unreliable software that misses requirements; Brooks's law and real failures (Therac-25, Patriot, Ariane 5, Mars Climate Orbiter, Knight Capital, CrowdStrike) illustrate it.
Software myths among managers, customers and practitioners must be recognised and avoided.
Software engineering's main answer to the crisis is a disciplined life cycle. The next chapter, Software Development Life Cycle (SDLC), explains the phases every software project goes through.