You are on page 1of 2

No Silver Bullet Summary

This article aims at discussing the problems faced by software developers and how these problems differ radically from the problems faced by people involved in the non-software domain. The author emphasizes that there exists no concrete solution to improve the productivity reliability and simplicity of computer software. He categorizes the problems faced by software developers in the following: 1. Complexity: Hardware progresses at a much faster rate than software. Software is a very complex concept and this complexity is in itself an essence. Scaling up of software is equivalent to the scaling up of its complexity. Any description of a software that overlooks its complexity decapitates its potency. 2. Conformity: Complexity is not just restricted to software but to the most fundamental laws of physics as well. However physicists believe that the complexity of physics can be simplified. No such notion holds true for software and in many cases software must conform because it is perceived by most as conformable. 3. Changeability: Software is constantly submitted to change. All successful software gets changed. Two processes are involved. As software is found useful people try it in many cases even outside its original domain. Second, as hardware advances, so does the supporting software. 4. Invisibility: Software cannot be graphically visualised. Although it can be represented using graphs, flow diagrams etc. they represent data in a non planer manner and are very difficult to understand. Past breakthroughs: High level languages: One of the most important breakthroughs is the development of high level programming languages. High level programming languages shield the complexity of the underlying bits, registers, conditions, branches, channels etc. But high level languages have their limitations. Time sharing: Time sharing attacks a different difficulty. It preserves immediacy and enables one to maintain an overview of complexity. It helps one to think better while working with slow turnaround machines. Unified programming environments: They attack accidental difficulties that result from using individual programs together. This breakthrough simulated the development of tools that aided software development. Hopes for silver bullet: High level languages like ADA introduced the philosophy of modularisation, abstract and abstract data types of hierarchical structuring. Object oriented programming languages have hierarchical types that allow the programmer to define general interfaces that can be refined using subordinate types. They also have the concept of abstract data types. These two concepts are orthogonal and provide real advances in building software. Artificial Intelligence also has provided hope for the silver bullet because it aims at developing a system that can tackle real life problems in a logical and inference based manner ie just like the way human beings think. AI separates application complexity from the program itself. This using the capabilities of an AI systems we can seek testing strategies, remember bug-type frequencies and offer optimization hints.

However such expert-systems too have many problems associated with them. The process of knowledge acquisition is very difficult as it involves finding articulate self-analytical experts who know why they do things and developing efficient techniques for extracting what they know and distilling it into rule bases. Automatic programming is another tool that can be used to ease the process of software development. Such tools develop programs by analyzing the problem statement. In-spite of all these efforts that have significantly aided the process of software development, biggest gain yet to be realised from programming environments is the use of integrated database systems to keep track of the myriad details that must be recalled accurately by the individual programmer and kept current for a group of collaborators on a single system. While concluding, the author mentions three areas that may help in developing better software. 1.Buy versus build 2.Requirements refinement and rapid prototyping: The most important step in software building is understanding the requirements of the client. Once the requirements have been understood, prototypes must be created. Prototypes typically perform the mainline tasks of the application, but make no attempt to handle the exceptional tasks, respond correctly to invalid inputs, or abort cleanly. Once a prototype has been established, it should be followed by a thoughtful incremental development. 3.Identification of great designers: The most important single effort we can mount is to develop ways to grow great designers. Great designers and great managers are both very rare. Hence opportunities must be provided for growing designers to interact with and stimulate each other.

Ameya More TY computer 110903049

You might also like