Summary:

This article is written by Fred Brooks. In this article he tells us the basic concepts related to
software development process to make people think that there are no silver bullets that will help
them to solve the software developments problems. 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. Brooks has divided the software qualities into
classes: essential qualities and accidental qualities. Essential qualities are extremely difficult to
address or improve while the accidental qualities can be improved via tool support. Essential
qualities are related towards understanding the problem, defining it and designing it that is too
hard in software development process. On the other hand accidental qualities are simply to
implement code and test.

The essential qualities are:

Complexity: Many of the classic problems of developing software products derive from this
essential complexity and its nonlinear increases with size. From the complexity comes the
difficulty of communication among team members, which leads to product flaws, cost
overruns, and schedule delays. Not only technical problems, but management problems as well
come from the complexity

Conformity: Software must conform to external constraints that make it difficult to reduce
complexity.    Much of the complexity of interacting with human systems is arbitrary, and since
software is perceived as changeable, it is most often seen as the thing which should conform, not
the human system. The accidental qualities are all about implementation and testing, and these
have been solved almost as well as they are likely to be solved, so don’t expect many more
breakthroughs.   Here are things that Brooks says have helped to reduce the impact of the
accidental qualities
Changeability: Changeability: We are just pushing bits around in the end; changing ideas.
Therefore it is always possible to change a piece of software. Software is inherently flexible
where as physical products are not. Change comes in two ways: people use the software in ways
not originally foreseen in the design and want better support for that; and the physical machine
OS changes underneath us.

Invisibility: We cannot see it all at once as you would a physical piece of something. It is also
very difficult even to visualize since there are many ways to look at the same design: “the reality
of software is not inherently embedded in space.” This inhibits communication of structure and
design.

Accidental Qualities: The accidental qualities are all about implementation and testing, and
these have been solved almost as well as they are likely to be solved, so don’t expect many more
breakthroughs. Here are things that Brooks says have helped to reduce the impact of the
accidental qualities.

Artificial Intelligence: The use of computers to solve problems that previously could only be
solved by applying human intelligence. I cannot identify a body of technology that is unique to
this field. Most of the work is problem-specific, and some abstraction or creativity is required to
see how to transfer it. The hard thing about building software is deciding what one wants to say,
not saying it.

High level languages: It lets the programmer concentrate on the logic of the problem to be
solved. The concrete machine program is concerned with bits, registers, conditions, channels,
disks, and such. To the extent that the high-level language embodies the constructs one wants in
the abstract program and avoids all lower ones, it eliminates a whole level of complexity that
was never inherent in the program at all.

Expert systems: An expert system is a program that contains a generalized inference engine and
a rule base, takes input data and assumptions, explores the inferences derivable from the rule
base, yields conclusions and advice, and offers to explain its results by retracing its reasoning for
the user.
Automatic programming: For almost 40 years, people have been anticipating and writing about
automatic programming, or the generation of a program for solving a problem from a statement
of the problem specifications. In automatic programming programmer gets specs from somebody
somewhere and is concerned with turning them into machine code.

Graphical programming: Number of software developers create their software by drawing it.

These engineers do not translate a paper flowchart into text source code, or use software tools to
transform a UML diagram into C++. With graphical programming, the diagram is the source
code, depicted as an arrangement of nodes. Each piece of data flows through the connections.

Program verification: There is no any silver bullet that would help us to eliminate error and
bugs in source code or in the whole system. Program verification is done so that program meets
its specification. Verification is very powerful concept we can no eliminate it.