Understanding Software: Definitions, Quality Challenges, and Development Processes
1️⃣Definition and characteristics of software
2️⃣ Software quality issues
3️⃣ Software Development Process
1️⃣Definition and characteristics of software
1) Changes Brought About by Software
What Kind of World Do We Live In?
Looking back at the era we live in, we have passed through the 1st, 2nd, and 3rd Industrial Revolutions, and we are now entering the age of the 4th Industrial Revolution - an era of intelligent information technology built on AI, IoT, Big Data, and autonomous driving.
So what makes all of this possible? It is the software that controls and drives these systems. We are living in a time where software plays a central role across society and the economy.
The Role of Software - The Case of Autonomous Driving
Tesla, a leader in the autonomous driving industry, uses numerous cameras and sensors to recognize objects, people, and lane markings, and to control the vehicle accordingly. What actually performs this judgment and control is software - invisible, yet operating deep within the system. The role of software will only continue to grow.
The Scale of Software - Understanding Size Through LOC
The size of software is measured in LOC (Lines of Code).
| Software | LOC |
|---|---|
| Practice code | Tens to hundreds of lines |
| Average mobile app | ~30,000 lines |
| Android OS | ~12 million lines |
| Windows OS | ~40 million lines |
| Modern high-end car | 100 million+ lines |
If 30,000 lines were printed on A4 paper (at roughly 40–50 lines per page), it would produce approximately 600 to 700 pages. Imagine someone handing you a 600-page book - just reading and understanding it would be an enormous challenge. The sheer scale of software is already staggering.
Software Defects and Quality Concerns
As the size of software grows, so does the number of potential defects.
Even the best software development companies in the United States are known to produce "8 to 12 defects per 1,000 lines of code."
Applying this to real-world scale:
A 30,000-line app → approximately 300 potential defects
A 100-million-line car → approximately 1,000,000 potential defects
Why do so many defects occur? The most fundamental reason is that software is still developed by humans. As long as humans are doing the development, human error is inevitable.
2) What Is Software?
We have already discussed software-centric society. So how do we define software itself? The most common definition is: a collection of instructions - source code programs - that control hardware. But if we take a broader view, the definition expands significantly.
The software development process is not focused solely on coding. It begins with gathering customer requirements, then moves through analysis, and then a design phase where those requirements are examined in concrete detail from a development perspective. From there, implementation (coding) takes place, followed by testing to verify that the software satisfies the original requirements, and finally the software is deployed.
Because software goes through this entire journey — from requirements to deployment — it produces files such as requirements specifications, architecture design documents, source code, and test result reports. Software, therefore, can be defined as all artifacts and data produced through the development process, including but not limited to the source code itself. This definition already implies that software development and maintenance are part of what software fundamentally is.
Why Must the Process Be Reflected in the Definition? This is directly tied to the four key characteristics of software.
1. Invisibility (비가시성)
The internal structure of software is not visible to the eye. When using an app or a website, you see the UI on screen, but the actual underlying structure is not clearly visible. This is the most defining characteristic of software.
Should we simply accept this invisibility? If we do, projects will become increasingly difficult to manage. Instead, we must make every effort to visualize the structure as much as possible. The most representative approach is architecture design - before any coding begins, identifying what components make up the software, how they interact, and what their interfaces look like. Visualization is a deliberate and necessary effort.
2. Non-Linearity (비선형성)
Software has a complex, non-linear structure. In a linear system, the flow of components is predictable and easy to follow. In a non-linear system, components are intricately entangled with one another.
The goal is to reduce this complexity, and this is addressed during the analysis and design phases. For example, if a system has a complexity level of 6 and we want to bring it down to 4 or 5, one approach is to introduce a mediating module between the existing modules. Instead of having them interface directly with each other, they communicate indirectly through the intermediary — and this reduces overall complexity. These structural decisions must be considered before programming begins.
3. Does Not Wear Out, But Continuously Changes (마모되지 않고 변경됨)
Hardware wears down with use — it degrades and eventually breaks. Software, on the other hand, does not wear out. The same software used today, tomorrow, a month from now, or a year from now on the same platform will always perform the same way. It does not deteriorate.
However, software is constantly changing. For how long? Until the product it is embedded in is no longer in use. Changes occur for many reasons — a user discovers a problem, an internal request is made, or new requirements emerge.
Consider a car, which is typically used for about 10 years, or a subway train, which can remain in service for around 30 years. The software embedded in these vehicles does not stop evolving once it is first released — it continues to be updated and modified throughout the entire lifespan of the product.
4. Human Intensive (사람 중심의 작업)
Hardware components are manufactured in factories and production lines, largely automated by robots. Software, however, is still built by people — and because of that, potential human error is inherent in the process.
The goal is to minimize human error and to detect faults before they lead to failures. The most representative tool for achieving this is testing. Through rigorous testing, we must actively work to find and eliminate the many defects that exist within software.
The Consequences: A 30% Success Rate
Due to these four characteristics, the success rate of IT projects involving software development is approximately 30%. One might assume that most projects succeed, but in reality, success requires hitting all three marks of QCD — Quality, Cost, and Delivery. Achieving all three simultaneously is extremely difficult, which is why the success rate remains so low.
Nevertheless, we must continue striving to raise that success rate and improve software quality, however incrementally.
Conclusion
Software is growing in scale at a rapid pace, and the number of potential defects grows proportionally. For this reason, systematic and thorough efforts to ensure software quality are absolutely essential.
2️⃣ Software quality issues
What Happens When Software Defects Occur?
When the final product is an aircraft or an automobile, software may appear to be just a small component. However, a small error made by a developer becomes a fault, which then leads to a failure, propagating through subsystems and eventually up to the entire system -ultimately influencing the final product and causing accidents. This is known as software fault propagation. In severe cases, it can result in the loss of human life or catastrophic damage to property.
Real-World Accident Cases Caused by Software
1. Medical Field; Therac-25 Radiation Therapy Machine
The Therac-25, a radiation therapy machine developed in 1985 by ACEL in Canada, is one of the most well-known examples. Because direct radiation exposure is harmful to the human body, the machine was designed with two modes: a low-power Electron mode and a high-power X-ray mode. In X-ray mode, a turntable was designed to intervene and prevent radiation from being directly applied to the patient.
However, due to a software malfunction, the turntable failed to activate even when the machine was in X-ray mode. As a result, between 1985 and 1987, 6 radiation overdose incidents occurred, leaving 3 people dead and 3 others with permanent radiation-related disabilities. This is one of the most cited examples of a small developer error leading to fatal consequences.
2. Space Industry; Ariane 5
In 1996, the Ariane 5 rocket, launched by the European Space Agency, exploded just 37 seconds after liftoff; at a height still visible to the naked eye from the ground.
The cause was traced to the reuse of software from the previous model, Ariane 4 (a 16-bit system), in the Ariane 5 (a 64-bit system) without accounting for the difference in bit architecture. During data conversion, an overflow error occurred in the variable representing altitude. Although the rocket was at a normal altitude, the software incorrectly determined that it had gone off course. Because the system was designed to self-destruct upon detecting a trajectory deviation, the rocket was automatically destroyed. Once again, a small developer oversight led to a catastrophic outcome.
3. Aviation; Boeing 737 MAX 8
In October 2018, a Boeing 737 MAX 8 crashed, killing all passengers on board. The aircraft was equipped with the MCAS (Maneuvering Characteristics Augmentation System), which controls the pitch of the aircraft and relies on data from the AOA (Angle of Attack) sensor.
The critical flaw was a software error that allowed the MCAS to activate even when the AOA sensor was malfunctioning. The system continuously commanded the horizontal tail to push the nose downward, and when the pilots were unable to override it, the aircraft crashed.
4. Automotive; Toyota Lexus ES350
In August 2009, a sudden unintended acceleration incident involving a Lexus ES350 in California, USA, resulted in the deaths of an entire family of four. The vehicle was equipped with an ETCS (Electronic Throttle Control System), and following the accident, a simulation experiment successfully reproduced the sudden acceleration by manipulating specific bit values in memory; providing experimental proof that the software was at fault.
Conclusion
These cases make it abundantly clear why ensuring software quality is of the utmost importance. Achieving that quality requires systematic efforts across process, engineering, and technical dimensions, and at the heart of those efforts lies testing.
3️⃣ Software Development Process
The Importance of Process for Quality Assurance
How can we ensure software quality? Watts Humphrey, a renowned software engineer, once said:
"The quality of a product is determined by the quality of the process used to develop and maintain it."
In other words, a better process leads to a better product. While delivering software to the customer is important, what truly matters is establishing and adhering to a well-defined process throughout the entire development lifecycle - from requirements analysis to architecture design.
Stages of Software Development
Software development progresses through the following stages:
Customer Requirements — Abstract and loosely defined requirements are received from the customer.
Requirements Analysis — The customer's requirements are broken down and analyzed from a development perspective.
Design — The HOW is defined: what structure the software will have and how it will behave. This is an indispensable stage in the development process.
Implementation (Coding) — Developers write the actual code based on the design.
Testing — The implemented software is verified to ensure it meets the design specifications and satisfies the original requirements.
Only after testing is complete is the software considered finished and ready for deployment to the customer. Thoroughly following each of these stages is the most fundamental way to improve the quality of delivered software.
Software Development Life Cycle (SDLC) Models
1. Waterfall Model
The most classic model, in which the development process flows sequentially from top to bottom. Like a waterfall.
Requirements Analysis → Design → Implementation → Testing → Maintenance
Each phase must be fully completed before moving on to the next. This model is best suited for projects with clear and well-defined requirements.
2. Prototyping Model
Rather than developing everything at once, this model involves first building a prototype of the most critical components from the customer's perspective, then gathering feedback before continuing development. The product is gradually refined based on customer evaluation.
This approach is far more flexible than the Waterfall model and can respond effectively even when customer requirements change during development.
3. Spiral Model
Like the Prototyping model, this approach develops software incrementally, prioritizing the most important requirements first. The key distinction is that risk analysis is explicitly integrated into every cycle of the process. At each spiral, risks are identified and analyzed, and the findings are incorporated into the next cycle; making it a more systematic and risk-aware development methodology.
4. V-Model
One of the most widely used models in practice today, the V-Model is particularly applied in projects where quality is paramount. It is derived from the Waterfall model and takes the shape of the letter "V".
The model places strong emphasis on Verification and Validation, mapping each development phase on the left side of the "V" to a corresponding testing phase on the right.
| Development Phase | Testing Phase |
|---|---|
| Customer Requirements | Acceptance Testing |
| Requirements Analysis | System Testing |
| Architecture Design | Integration Testing |
| Detailed Design | Unit Testing |
Summary of Today's Key Takeaways
Today's content can be summarized into three main points:
① Definition and Characteristics of Software - Software is not merely source code; it encompasses all artifacts and data produced throughout the entire development process. Its key characteristics include invisibility, non-linearity, human-intensive work, and continuous change.
② The Importance of Software Quality Assurance - These characteristics make quality assurance inherently difficult, but as the accident case studies demonstrate, ensuring quality is absolutely non-negotiable.
③ Software Development Processes - To achieve quality, structured processes must be applied. The four representative models are the Waterfall Model, Prototyping Model, Spiral Model, and V-Model.
