No Silver Bullet
Reviewer: Tingjun Zhang
What is this article about?
"When it comes to software developing, people are always getting into some troubles, such as missed schedules, blown budgets, and flawed products, which make developing work very painful. People are desperate to find a silver bullet (an ultimate solution) for those problems. However, when we look back at the past decade, we see no silver bullet."
————Frederick P. Brooks, Jr
This article is trying to tell us why there is still no silver bullet, past breakthroughs against those issues and future hope for the silver (potential ultimate solutions).
Essential Difficulties
The author clarifies that the comparison between the slow pace of software development and the pace of hardware development is actually not fair. The pace of Hardware development is actually rare.
It is specification, design and testing of conceptual construct that make software development painful.
The author concludes 4 main properties of the essential difficulties : complexity, conformity, changeability, and invisibility.
- Complexity - The Software itself is more complex than other human construct. And since software systems have more states than computers do, their complexity would increase much more than linearly. Unlike mathematics and the physical sciences, the complexities are the essential properties of software development, which is one of the reason why it is almost impossible to abstract certain essence to simplicify problems we faced during software developing. Both technical problems and management problems count when we try to overview and control all loose ends.
- Conformity - Conformation to other complex interfaces is a must for the software. And many complexities come from those conformations, which can not be avoided.
- Changeability - Software is different from computers, cars or ships. The cost for changes is relatively cheap, and their changes are closely relative to their applications. They change very often.
- Invisibility - For the current period, there is still not a ready geometric representation for software, which made it hard for communication when developers are trying to discuss about the design.
Past Breakthroughs Solved Accidental Difficulties
The author gives three important breakthroughs in software development in the past.
- High-level languages - A high-level language that can potentially ease the pain for accidental complexity. However, sometimes it would create a tool-mastery burden to developers.
- Time-sharing - It shortens system response time, but once the response time goes less than 100 milliseconds, to human race, no further benefits are to be expected.
- Unified programming environments - Because of them, each new tool could be applied to any programs that used standard formats, which attack the accidental difficulties that result from using individual programs together.
Hopes for the Silver
- Ada and other high-level language advances - As a general-purpose high-level language, it provides a philosophy of modularization, abstract data types and hierarchical structuring. Entry level programmers could benefit from the transition up from accidental complexities into such more abstract structured solutions.
- Object-oriented programming - It can help remove all the accidental difficulties from the expression of the design, but the author doesn't think it won't help for problems caused by the complexities of the design itself.
- Artificial intelligence - The main idea is that the author doesn't think AI would provide any revolutionary breakthroughs. The reason he gives is that current AI techniques used in speech/image recognition don't have appreciable difference compared with other programming practice. Current AI techniques are unable to make abstraction for certain problems, in other words, the AI today still can't "think".
- Expert systems - The author claimed that the expert systems are the most important part of the artificial intelligence art. The author believes that this technology provides the separation of the application complexity from the program itself. In software engineering tasks, it may give suggestions on testing strategies, which benefits inexperienced programmer a lot.
- Other approaches - The author also introduced some other approaches such as, automatic programming, graphical programming, program verification, environments & tools and workstations.
Promising Attacks on the Conceptual Essence
The author gives some technological attacks that are promising to solve software problems.
Three most essential aspects are: "Buy vesus build", "Requirements refinement and rapid prototyping" and "Great designers".