Summary of No Silver Bullet Research paper

1. No silver bullet
Group member: Shakeel khan
InamUllah shah
Abasyn university Islamabad

2. Introduction
No silver bullet
There is no straight forward way on which we go and sure that we got the
extreme solution of the problem.
OR
There are no single SDLC or methodology which we follow and say that, this
the best way and technique to follow for solving the software problem.

3. Essence and Accidents
There are two problems facing software engineering.
1. essence: difficulties inherent in the nature of software.
e.g. complex conceptual constructs( algorithm, data sets,
function, relationship
2. accidents: difficulties related to the production of software.
e.g. representing the constructs in programming language.

4. The Essence
Brooks divides the essence into four subcategories
1. complexity
2. conformity
3. changeability
4. invisibility

5. complexity
• No two parts are alike.
• Huge number of states.
• Complexity grows nonlinearly with size.
• Can’t know the whole domain, process, or system.
• Introduces technical and managerial problems leading to unreliability.
• No two part are alike.
• Complete structure and function.

6. Cont…
Problems resulting from complexity
• difficult team communication.
• product flaws, cost overruns.
• personnel turnover (loss of knowledge) .
• project overview is difficult.

7. Conformity
• Most of the time software systems have to interface with an existing
system.
• Even for a new system, the perception is that, it is easier to make software
interfaces conform to other parts of the system .
• We need not to change the whole existing system because of new
software.
• May be difficult to change the environment, however if the environment
changes, the software system is expected to adapt.

8. Changeability
• The nature of software change is another essential problem.
• When software changes, unlike other entities, typically it is the function
being modified. Because software is relatively easy to change, it changes
often.
• Since software is easy to change software gets changed frequently and
deviates from the initial design, adding new features , supporting new
hardware.

9. Invisibility
• The code is invisible. There’s only the external input/output view.
• There is no simple geometric representation for software.
• Structure is terribly complex and hidden.
• Software does not have one map or graph, it will have multiple maps and
graphs.
• But There is nothing physical to visualize, it is hard to see an abstract
concept.

10. Past breakthroughs solved accidental difficulties
High level language
It allows that some types on data structures,
operation, classes etc. to be used by any machine. Programmers don’t have to
develop software for individual machines. Powerful stroke for software
productivity, reliability, & simplicity . Removed the low level complexities.
Time sharing
Increased turnaround time and productivity of programmer.
Improvement is not as much as that of high-level language. System response
time is no longer an issue. Programs run faster because of the high-level
languages.

11. Hopes for the silver
Ada and other high-level languages
Ada high-level computer
programming language used chiefly in real-time computerized control
systems. Ada programming language and high-level languages are promising
to tackle some of the issues experienced in software engineering, Ada was
specifically designed for system functions where overall system efficiency and
reliability is vital.

12. Cont…
Object-oriented programming
Its two important concepts, abstract
data types and hierarchical types, represent real advances in the art of
building software. Helps in design, but do not solve design complexity
Problem.
Artificial intelligence
It is computer hardware and software processes
which choose the best solution in a given problem likely to be chosen by
humans e.g. human and hardware interaction .

13. Cont…
Expert System
Every software system should be designed and built in
such a manner that it would be able to test and diagnose itself when it
malfunctions, However this would not be an easy task to implement. Building
an expert system would require very knowledgeable programmers which
could build a general system to solve multiple complex tasks.

14. Cont…
Automatic Programming
Generation of a program from problem
specification. It is essential to have software systems that are able to program
themselves, and write program solutions of problem from a problem statement
automatically.
Graphical programming
presentation of software functions in a
graphical manner like flow charts . But problem is diagrams tend to be bigger
than a normal screen size of a computer. More fundamentally, software is
very difficult to visualize.

15. Cont..
Program verification
Program verification is where most programmers
spend time and it is one of the most important steps in a software life-cycle.
Verifying a program before the testing phase can eliminate a lot of anomalies,
it could even reduce the time spent on testing the actual software because
each requirement would be verified before being implemented.
Environments and tools
Given the powerful computers available in
this modern day to surely facilitate software development. But magical
enhancement thus cannot be expected.

16. Attacks the essence
Buys vs Build
Good generalized software tools (mass market software for
writing, drawing, file management, and spreadsheets) can have a big impact
on productivity. In the past 20 years, a large number of open source tools
have reinforced the value of reusing existing software.
Refinement and rapid Programming
The hardest part of
software is determining exactly what to build. Must show product to
customer to get complete specification .Need for iterative feedback.

17. Cont…
Incremental development
The most successful software is grown in
stages, not developed in a single stage of software construction. The
approach necessitates top-down design, thus allowing easy backtracking and
detecting fundamental defects as early as possible.
Great Designer
Great designers are orders-of-magnitude better at
creating small and cheap code quickly. These designers should be treated like
star managers, and should be identified quickly.

18. Conclusion
• No one advance will give a great improvement by which the accidental
difficulties can be solved.
• Even if we remove all accidental difficulties still at its essence software
development is difficult.
• There is still a hope for silver for solving software related problems and
thus for the betterment of later issues.
• The real problem of software engineering is dealing with ever-changing
requirements.
• No model, method, artifact, or tool offered to date has succeeded to
overcome this problem.

19. Any Question…
Thanks you