|
Software Development Methods
A well-known software crisis began in the middle of 1960s. In order to overcome this crisis, the term software engineering was proposed at two famous NATO conferences held in 1968 and 1969, and will be continuously developed and improved in the future. At the same time, software researchers are constantly exploring new software development methods. So far, eight types of software development methods have been formed.
I. parnas Method The earliest software development method was proposed by D. parnas in 1972. Since the software had serious problems in Maintainability and reliability at that time, the method proposed by parnas was aimed at these two problems. First, parnas proposes the principle of information hiding: In the outline design, it lists the factors that may change in the future, and puts these factors into individual modules during module division. In this way, when you need to modify the software due to these factors in the future, you only need to modify these individual modules, and other modules will not be affected. Information Hiding technology not only improves Software maintainability, but also avoids the spread of errors and improves software reliability. The principle of information hiding has become an important principle in software engineering.
The second principle proposed by parnas is to take measures to cope with possible unexpected failures during software design. Software is very fragile and may cause serious accidents due to a small error. Therefore, we must strengthen prevention. For example, you should take the device status word and check whether the device is normal before using the device. In addition, check between modules to prevent the spread of errors.
Parnas provides profound insights on software development. Unfortunately, he did not give a clear workflow. Therefore, this method cannot be used independently and can only be used as a supplement to other methods. Ii. Sasa Method In 1978, E. Yourdon and L. L. Constantine proposed a structured method, that is, sasd, also known as functional-oriented software development methods or data flow-oriented software development methods. In 1979, tomdemarco further improved this method.
Yourdon method is the most widely used software development method in 1980s. It first uses the structured analysis (SA) to analyze the requirements of the software, then uses the structured design (SD) method for the overall design, and finally structured programming (SP ). This method not only has clear development steps, SA, SD, and SP complement each other in one breath, but also provides two typical software structures (transform and transaction) for reference, the success rate of software development is greatly improved, which is favored by software developers. Iii. Data Structure-oriented software development methods Jackson Method
In 1975, M. A. Jackson proposed a class of software development methods that are still widely used. This method starts with the input and output data structure of the target system, exports the program framework structure, and adds other details to obtain the complete program structure. This method is particularly effective for small and medium-sized systems with clear input and output data structures, such as file table processing in commercial applications. This method can also be combined with other methods for detailed design of modules.
The Jackson method is sometimes called a data-oriented software design method. Warnier Method
In 1974, J. D. warnier proposed a software development method similar to the Jackson method. There are three differences: first, they use different graphics tools, respectively using the warnier diagram and the Jackson diagram; the other difference is that the pseudo code is different; the most important difference is that when constructing a program framework, the warnier method only considers the input data structure, while the Jackson method not only considers the input data structure, but also the output data structure. Iv. Problem Analysis Pam problem analysis method. Pam (problemanalysismethod) is a software development method proposed by Hitachi at the end of 1980s.
Pam Methods want to take into account the advantages of Yourdon, Jackson, and bottom-up software development methods to avoid their defects. Its basic idea is: taking into account the input and output data structures, guiding the system decomposition and gradually integrating under the guidance of system analysis. The specific steps of this method are to export the basic processing boxes from the input and output data structures, analyze the relations between the processing boxes, and gradually integrate the processing boxes according to their relations, until the pad diagram of the entire system is drawn. It can be seen from the above steps that this method is essentially a comprehensive bottom-up method, but a purposeful decomposition has been carried out before the gradual integration, this aims to fully consider the system's input and output data structures.
Another advantage of the PAM method is the use of pad graphs. This is a two-dimensional tree structure, which is one of the best detailed design representations so far, far better than NS charts and PDL languages.
This method is popular in Japan, and the success rate of software development is also high. Because there is a gap between the input and output data structures and the entire system, this method is only applicable to small and medium problems. V. Object-Oriented Software Development Methods Object-oriented technology is a revolution of software technology and has a milestone in the history of software development.
With the development of OOP to Ood and OOA, An Object-Oriented Software Development Method OMT (lbjectmodellingtechnique) is formed ). This is a combination of bottom-up and top-down methods, and it is based on object modeling, which not only considers the input and output data structures, it actually contains the data structure of all objects. Therefore, OMT has completely achieved what Pam has not fully achieved. Moreover, OO technology has made substantial breakthroughs in the three key links and quality indicators of Software Development: requirement analysis, maintainability, and reliability, it completely solved these serious problems and declared the end of the software crisis. Bottom-up Induction
The first step of OMT is to start with the problem statement and construct a system model. Export the class system from the real system, that is, the object model includes the class attributes, the inheritance relationship with the subclass, parent class, and the association between classes. A class is an abstraction of a group of concrete instances (objective objects) with similar attributes and behaviors. A parent class is an induction of several sub-classes. Therefore, this is a bottom-up induction process. In the process of bottom-up induction, to make the subclass more reasonable to inherit the attributes and behaviors of the parent class, it may need to be modified from top to bottom to make the entire class system more reasonable. Because the structure of this system is from concrete to abstract, and then from abstract to specific, in line with the laws of human thinking, It is faster and more convenient to complete the task. This is in stark contrast to the top-down Yourdon method. Constructing a system model in the Yourdon method is the most difficult step, because the top-down "TOP" is a castle in the air and lacks a solid foundation, and functional decomposition is quite arbitrary, therefore, developers must have rich software development experience. In OMT, this work can be quickly completed by General developers. After the object model is created, it is easy to export the dynamic model and function model on this basis. Together, these three models form the system model to be solved. Top-down decomposition
After the system model is created, it is decomposed. Unlike the Yourdon method, the OMT method is usually divided by service. A service is a set of functions with common goals, such as I/O processing and graphic processing. The decomposition of this step is usually very clear, and further decomposition of these subsystems is also relatively easy because of a more specific system model. Therefore, OMT also has the advantage of the top-down method, that is, it can effectively control the complexity of the module and avoid the difficulty and uncertainty of functional decomposition in Yourdon method. OMT is based on the object model.
Each object class consists of a Data Structure (attribute) and an operation (behavior). All relevant data structures (including input and output data structures) constitute the basis for software development. Therefore, the gap between the input and output data structures and the entire system in the Jackson method and Pam does not exist in OMT. OMT not only has advantages of Jackson method and Pam, but also can be applied to large systems. More importantly, in the Jackson and Pam methods, when their starting point-the input and output data structures (that is, the boundaries of the system) change, the entire software must be retried. However, in OMT, the changes to the system boundary only increase or decrease some objects, and the whole system changes a little. Thorough Requirement Analysis
Incomplete requirement analysis is one of the main causes of software failure. Even now, this risk still exists. Traditional software development methods cannot change user requirements during the development process, resulting in various problems. It is precisely for this reason that people have proposed prototype methods, launched the exploration prototype, experimental prototype and evolutionary prototype, and actively encourage users to improve their needs. After each requirement for improvement, a new evolutionary prototype is formed for users to try out until users are basically satisfied, greatly improving the software success rate. However, it requires software developers to quickly generate these prototypes, which requires support from tools that automatically generate code. OMT completely solves this problem. Because the requirement analysis process is consistent with the system model formation process, the discussion between developers and users begins with the specific instances (entities) that users are familiar. Developers must understand the real system before exporting the system model. This gives users and developers a common language and avoids various problems that may occur in traditional requirement analysis. Maintainability is greatly improved
Software development methods before OMT are based on functional decomposition. Although software engineering has made great efforts in maintenance, Software maintainability has been greatly improved. However, in essence, software based on functional decomposition is not easy to maintain. This is because a major change or even re-engineering of the developed software system will occur if the functions change. More seriously, modification is difficult in such software systems. For various reasons, even minor modifications may introduce new errors. Therefore, traditional development methods may lead to a series of serious problems, such as software cost growth out of control and software quality failure to guarantee. It is OMT that improves Software maintainability.
OMT is based on the object model of the target system, rather than functional decomposition. The function is the use of objects. It depends on application details and is constantly changing during development. Because the object exists objectively, when the demand changes, the object nature is more stable than the object usage, so that the software system built on the object structure is more stable.
More importantly, OMT completely solves the maintainability of the software. In the OO language, subclasses not only inherit the attributes and behaviors of the parent class, but also reload a behavior of the parent class (virtual function ). With this feature, we can easily modify functions: introduce a certain type of sub-classes and reload some of the actions to be modified (that is, virtual functions or virtual methods, that is, to redefine them. Since no modification is introduced in the original program module, the software can be completely modified, and the maintainability of the software is also completely solved. OO technology also improves software reliability and robustness. Vi. Visual Development Method Visual Development was one of the two largest hot spots in the software field in 1990s. With the rise of graphical user interfaces, the proportion of user interfaces in software systems is also growing, and some are even as high as 60 ~ 70%. The cause of this problem is that the generation of graphic interface elements is inconvenient. For this reason, Windows provides the application programming interface, which contains more than 600 functions, greatly facilitating the development of graphical user interfaces. However, in these functions, a large number of function parameters are related to a large number of constants, making development based on Windows APIs quite difficult. Therefore, Borland C ++ has introduced the object windows programming. It encapsulates all parts of the API with object classes, provides a large number of predefined classes, and defines many member functions for these. With the inheritance of sub-classes to parent classes and the reference of class functions by instances, application development can save a lot of class definitions, removes the need to define a large number of member functions or only a small number of modifications are required to define child classes.
Object windows also provides many standard defaults, greatly reducing the workload of application development. But it is still a heavy burden for non-professionals to master them. Therefore, visual development tools have been developed using Windows APIs or Borland C ++ object windows.
Visual Development is based on the graphic user interface provided by the visual development tool, through the operation interface elements, such as menus, buttons, dialog boxes, edit boxes, single quotes, check boxes, list boxes, and scroll bars, the application software is automatically generated by the visual development tool.
This type of application software works in an event-driven manner. For each event, the system generates the corresponding message and passes it to the corresponding message response function. These message response functions are automatically loaded when software is generated by visual development tools.
Author member name: zxj16 |
|
