No Silver Bullet - Essence and Accidents of Software Engineering

NO SILVER BULLETS
ESSENSE AND ACCIDENTS OF SOFTWARE ENGINEERING
- Fredrick P. Brooks, Jr.
@ADITIABHANG

”There is no single development, in either technology or in management
technique, that by itself promises even one order of magnitude
improvement in productivity, in reliability, in simplicity.”
monster of missed
schedules, blown
budgets, and
flawed products
Kill werewolves (folklore)
(software
development)
We hear desperate cries for something to make software costs drop as rapidly as computer hardware costs do.
@ADITIABHANG

- Comparison between software and hardware advancement.
- Innovations in the software can yield an "order-of-magnitude" improvement.
- Example given in medicine where doctors where taught the benefits of cleanliness improving health of patients
- In the same way improving processes in software can help improve software step by step.
- A disciplined, consistent effort to develop, propagate, and exploit these innovations should indeed yield an
order-of-magnitude improvement.
INTRODUCTION
“The anomaly is not that software progress is so slow, but
that computer hardware progress is so fast”
@ADITIABHANG

ESSENTIAL AND ACCIDENTAL DIFFICULTIES
Essential difficulties, those inherent in software; and Accidental difficulties, where we make things harder for
ourselves than we need to, but that are not inherent to the process.
Essential Difficulties:
- What a software does
- Characteristic of software
- Construct of interlocking concepts
- Data sets, relationship among them, algorithm, and function invocation.
- Inherent properties of modern software :
- Complexity,
- Conformity,
- Changeability,
- Invisibility
Accidental Difficulties:
- Issues related when working with the development of software.
- Can be overcome and increase productivity.
@ADITIABHANG

“ I believe the hard part of building software to be the
specification, design, and testing of this conceptual construct,
not the labor of representing it and testing the fidelity of the
representation. ” – Fredrick Brooks.
Brooks argues that syntax errors are bound to happen by even any perfect programmer; but these errors are not a
big deal as compared to the conceptual errors. If this is true, then building software will always be hard, and there is
inherently no silver bullet.
Inherent properties in Modern Software:
- Complexity
- Conformity
- Changeability
- Invisibility
These properties, not being accidental, representing software in various forms do not affect them.
@ADITIABHANG

Sources of Essential Difficulties
Complexity:
- Software entities are more complex than we can think.
- No two parts are same.
- Number of possible states grows much faster than lines of code.
- They interact with each other in non-linear fashion.
- The complexity as a whole increase much more than linearly.
“The complexity of software is an essential property, not an accidental one.”
@ADITIABHANG

Technical Problems Management Problems
• Communication among team members.
o Product flaws, cost overruns, schedule delays.
• Complexity in understanding (and enumerating) all
possible states.
o This drives unreliability.
• Programs hard to use due to the difficulty of invoking
function.
• Harder to extend newer functionality and
consequently introducing side effects.
• Security of a software system more difficult to
understand.
• Project overview is difficult
o conceptual integrity is hard to achieve
• Communication overhead
o cost overruns and schedule delays
• Huge number of states are not reliable
o hard to find and control all loose ends
• Understanding burden and tremendous learning curve
• Poor usability and poor maintainability of complex
functions and structure.
Issues formed due to complexity:
@ADITIABHANG

Conformity:
“much of the complexity that he(software engineer) must master is
arbitrary complexity, forced without rhyme or reason by the many human
institutions and systems to which his interfaces must conform.”
• Unlike physics no unifying principles, must connect with existing systems.
• Example of VP changing business process.
• Software must conform with respect to its operating systems and hardware.
• Often called as ”Last kid on the block”
• We do not need to change the entire system to by arrival of new software.
@ADITIABHANG

Changeability:
• Software are always under pressure for change.
• So are buildings, cars, and computers.
• Software EQUALS functionality.
• Clients don’t know how much work is required
• Two processes are at work when software changes.
• First, Extending basic functions
• Second, must be compatible with new vehicle.
• Software is easy to change, but hardware isn’t .
• Hardware change:
Once an Intel processor goes to the production line, the replacement cost is extremely high.
Example: Pentium FDIV bug, return incorrect binary floating-point results when dividing a number, had
replacement cost of $475 million.
• Software change:
Example:
If a Microsoft software tool has a bug, the replacement cost is negligible. Only needs few minutes to
redownload, or to update the software.
@ADITIABHANG

• Sounds like finally there is some advantage software has over hardware.
• But the effect of changeability is that software is always under pressure for change.
• Software changes frequently; for new feature or to support new hardware.
• Complexity becomes harder to follow.
• People underestimate the effects of changeability in software systems.
• Conformity and Changeability are among the reasons to why reusability is not successful in
software systems.
• As components keeps changing, changeability and conformity makes it hard to develop
component-based software.
“A software product is embedded in a cultural matrix of
applications, users, laws, and hardware – all of which
change continually and force changes upon the software.”
@ADITIABHANG

Invisibility:
“Software is invisible and cannot be visualized”
• Software has no 3D way which can help get a bird’s view on the software project.
• Represent the flow of control, the flow of data, patterns of dependency, time sequence, name-space
relationships.
• Everyone has different view about the software; communication becomes difficult.
• No easy way of representation
• No common geometrical shapes
• Build a piece of software without having a clear idea of how the final product would look or perform.
• Code is invisible; the structure is hidden and complex
• Structure do have one common graphs or diagrams, it has multiple.
• Only available is input and expected output.
@ADITIABHANG

Invisibility and Visualization tools:
• Visualization tools for computer aided designs are helpful to
computer engineers.
• Such tools helps to show the layout of the circuit (having a 2D
shape), makes it easy to design a chip.
• Although visualization tools for software are not very helpful.
• For that there is no physical representation, nothing to ‘see’
• No physical distance to measure and build for a software.
Silicon chips have diagrams
Buildings have floor plans
Lands have maps
@ADITIABHANG

Past Breakthrough Solved Accidental Difficulties:
The three steps in software technology development that have been most fruitful in the past,
I. High Level Language
II. Time Sharing
III. Integrated Programming Environment (libraries, unified file formats, pipes and filters, etc.)
“We discover that each attacked a different major difficulty in building software, but that those difficulties
have been accidental, not essential, difficulties.”
@ADITIABHANG

High Level Language:
• The most powerful thing happened in the history of software
development.
• It frees a program from much of its accidental complexity.
• Provides abstract program consisting types of data structures,
operations, data types, etc.,
• Makes learning of a programming language easy and write
‘hello world’ program without any struggle.
• Powerful stroke for software productivity, reliability and
simplicity.
• Removed the low-level complexities
@ADITIABHANG

Time- Sharing:
• Time-sharing preserves the quality of sense of urgency,
• Helps in maintain the overview of complexity.
• Increased productivity of programmers.
• program logic in context because of reduced compilation and execution.
• Programs runs faster due to ability of high-level language
@ADITIABHANG

Unified programming environments:
• Unix and Interlisp improved software productivity by
integral factors.
• Provided integrated libraries, unified file formats, and
pipes and filters, which helped use individual programs
together.
• Development of whole tool benches.
@ADITIABHANG

Is there any hope for Silver Bullet? Yes.. there is ‘hope’.
“A disciplined, consistent effort to develop, propagate, and exploit these innovations should
indeed yield an order of magnitude improvement.”
“There is no royal road, but there is a road.”
@ADITIABHANG

Hopes for the silver bullet:
1. ADA and other programming language
• It is the philosophy of modularization, of abstract data types, of hierarchical structuring.
2. OOP
• Abstract data type
• Object’s structure must be hidden, object’s data types must be defined by its name, set of proper values
and operations.
• Hierarchical types
• Define variables or objects based on their purpose in program
• Such advances can do no more than to remove all the accidental difficulties from the expression of the design.
Helps in design, but do not solve problem of design complexity.
@ADITIABHANG

3. Artificial Intelligence:
Two quite different definitions of AI
AI-1: The use of computers to solve problems that previously could only be solved by applying human
intelligence.
Al-2: The use of a specific set of programming techniques known as heuristic or rule-based programming.
Once a person understand a problem and working, most of the work becomes problem specific. Only thing
remains is to share it. Hence, it longer remains a unique technology or AI.
4. Expert Systems
• Program contains generalized inference and rule base, take inputs and assumptions, explores the guesswork
derived from the rule base, yields conclusion and advice and offers an explanation to its result.
• The inference engines typically can deal with fuzzy or probabilistic data and rules, in addition to purely
deterministic logic.
@ADITIABHANG

Advantages of Expert Systems over programmed systems:
1. Application independence and varied use.
2. Rule sets can encode universal ideas that can be applied to different applications, thereby distributing
complexity.
How can this technology be applied to the software-engineering task?
• Systems can suggest interface rules,
• advise on testing strategies,
• remember bug-type frequencies,
• and offer optimization hints.
@ADITIABHANG

5. Automatic Programming
Parnas [4] implies that the term is used for glamour, not for semantic content, asserting,
“In short, automatic programming has always been a euphemism for programming with a higher-level
language than was presently available to the programmer.”
• He argues, that in most cases it is the solution method, not the problem, whose specification must be given.
• Used successfully for specific tasks. (integrating differential equations)
6. Graphical Programming:
• The theorist used to justify the approach by considering flowcharts as the ideal program-design medium.
• The flowchart to be very poor abstraction of software structure.
• Useless design tool used by programmers since it is used after writing programs, not before.
• A software system cannot be visualized in the same way that hardware systems can.
@ADITIABHANG

7. Program Verification:
• Program verification is a very powerful concept, unfortunately there is no magic here.
• Verification might reduce the program-testing load, it cannot eliminate it.
• Even perfect program verification can only establish that a program meets its specification, which itself is a
hardest part of getting a complete and consistent specification.
8. Environment and Tools:
• Language-specific smart editors is freedom from syntactic errors and simple semantic errors.
• The biggest gain was the use of integrated database systems.
• Where myriad details would be tracked and recalled by the individual programmer or any group of
collaborators.
@ADITIABHANG

9. Workstations:
• Increase in power and memory size of workstations would not guarantee increase in programmer’s
developing speed.
• Even with a factor of 10 speed in machines will still leave thinking time to the programmers.
@ADITIABHANG

Promising attacks on the Conceptual Essence:
Brooks gives us the productivity formula which as believed by him is that the conceptual components of the
software development task takes most of the time.
For that Brooks offers us three recommendations that consider attacks that address the essence of the software
problem, still speak to us today:
• Reuse
o Buy vs Build
• Incremental development,
o Requirement refinement and rapid prototyping
• Investing in your software developers.
o Great designers.
@ADITIABHANG

1. Buy vs. Build
• It is cheaper to buy production ready software than try to write homegrown software.
• Software is immediately available.
• Buy software and distribute among developers as there is no replication fee.
2. Incremental development
• Grow software systems, not to build them.
• Easy backtracking
• Rapid prototyping
• Iterative extraction and requirement refinement.
• Prototypes typically perform the mainline tasks of the application
• Client can test it for consistency and usability and ask for the needed refinement of the requirements.
@ADITIABHANG

3. Great Designers:
• We can get good designs by following good practices instead of poor ones.
• Good design practices can be taught.
• Programmers being the intelligent part of the population, can learn good designs.
• Brook argues that great design minds (meaning individuals) can accomplish more than a committee of
designers.
• Useful software systems have been designed by committees and built as part of multipart projects, like
Cobol, PL/I, Algol, MVS/370, and MS-DOS.
• But the products made by one or a few designers are truly passionate fans of software systems, for example,
Unix, APL, Pascal, Modula, the Smalltalk interface, even Fortran.
@ADITIABHANG

Ways to deal with the essential difficulties:
• Complexity –
o Breakdown the system into module which can managed.
o Breakdown the development process into phases, tasks, and
subtasks.
o Pair programming, or team programming
• Conformity and Changeability –
o Change the management system with planning
o Configure the management
• Invisibility –
o Use different models to gain a different perspective on the
system
o Discuss the viewpoints
@ADITIABHANG

Conclusion:
• No single advancement can guarantee 10x improvement.
• Although all the accidental difficulties can be solved.
• Even if all the accidental difficulties are removes, coping up the
essence of software development remains challenging.
• Dealing with ever-changing requirements is the real problem of the
software engineering.
• No tool, method, model or artifact available till date has succeeded in
overcoming this problem.
• Hope persist for silver bullet for solving software related problems
and therefore, the betterment of the later issues.
@ADITIABHANG

No Silver Bullet - Essence and Accidents of Software Engineering

More Related Content

What's hot (20)

Similar to No Silver Bullet - Essence and Accidents of Software Engineering (20)

Recently uploaded (20)

No Silver Bullet - Essence and Accidents of Software Engineering