Software Engineering)

Document directory

•  

Summary

Computer software plays an increasingly important role in human society. However, the development of software technology has never been freed from the "software crisis. This article focuses on the methodology characteristics of software engineering from the perspective of methodology of science and technology: the ideas, methods, and design principles of software engineering; software Engineering is the practical, social, complex, and Countermeasure of Technical and technical methods; software process and related models.

Keywords

Methodology software crisis Software Engineering Software Process

Text 1. Importance of software technology methodology

In recent years, computer science has developed rapidly in branch disciplines and application fields such as hardware development, software development, and network communication, computer Applications have penetrated into various industries, fields, and even thousands of households in human society. With the development of computer technology and the popularization of computer applications, the information society and the Internet age are getting closer and closer, and computer technology is playing an increasingly important role in human society. In his book "Digital survival", American futuristic scientist negropondi predicted that "computing is no longer only related to computers. It determines our survival"

As computer-based systems increase in quantity, complexity, and application, they have put forward higher requirements for ubiquitous computer software: wider to solve endless application problems; more refined, it is easier to complete tasks securely and reliably to adapt to the popularization of thousands of households. To achieve this goal, it is not enough to rely solely on the existing ideas and methods.

At present, several major software companies in the world have monopolized an important field of software technology. China's software industry must master the core technology of software development, that is, the idea and method of software development, so as to develop innovative software with independent intellectual property rights according to China's development needs. Software Engineering Research is currently a hot field in computer science, and new theories and practices are emerging. Using this knowledge to learn, apply, and innovate is an opportunity and way for China's software industry to catch up with the world.

Methodology plays a decisive role in the development of software technology. As maozedong once said: "Our task is to cross the river, but we cannot cross the river without bridges or ships. If the problem of bridges and ships is not solved, crossing the river is just empty talk. If you don't solve the problem, you just need to say a bit about the task ." It is necessary for software technicians to review all links in the software development process from the perspective of philosophy and methodology, and deeply understand the connection between software engineering and methodology, so as to improve and develop the existing software engineering technology, digest and absorb advanced ideas, methods and technologies, improve the quality and productivity of software, to adapt to the real world's new requirements for the software industry. This paper discusses the problems, ideas, methods and new technologies of software engineering from the perspective of the methodology of science and technology.

2. "Software Crisis" and software engineering

Although futuristic scientists show us a bright future in the information age, there is a huge gap between ideals and reality after all. Computer Hardware Technology follows the Moore's Law to accelerate development. However, the progress of software technology has been relatively slow, and the gap and accumulation of problems have formed an increasingly acute contradiction, this led to the "software crisis ".

The software crisis comes down to the following problems:

The scale and complexity of software projects are growing. Due to the lack of systematic and effective methods, existing development knowledge, experience and related data are difficult to accumulate and reuse, the repetitive process of software system development wastes a lot of manpower, material resources, financial resources and time.

The software development work lacks effective analysis methods and design methods, the plan is difficult to develop, the budget is often exceeded, the progress plan cannot be followed, and the Development completion time is delayed.

Since software requirements are not clearly defined or cannot be clearly expressed at the initial stage of development, software engineers and users fail to communicate effectively in a timely manner after the development starts, this results in concentrated exposure of conflicts between requirements and reality in the middle and late stages of development.

There are no uniform and accepted methods and technical specifications in the development process, and the data in the design and implementation processes is incomplete, making the software difficult to maintain.

Lack of effective evaluation standards, failure to fully perform testing during the testing phase, poor quality of submitted software, and a large number of problems exposed during operation.

The most prominent example of the "Software Crisis" is the ibm360 operating system developed by IBM from 1963 to 1966. This project took a lot of manpower and material resources, but the quality of the software obtained was very bad. According to statistics, each of its new versions is corrected by finding more than 1000 program errors in the previous version. "Just as a fleeing beast falls into the quagmire and makes a dying struggle, the more struggling it is, the deeper it is. In the end, we cannot escape the disaster ,......, The program design work is just like this ,......, A batch of programmers are forced to struggle in the quagmire ,......, No one expected the problem to be in such a dilemma ......" The lessons of history tell us that there is no correct method, and the success of the project cannot be guaranteed by excellent teams and advanced technologies.

To solve the "software crisis", many computer and software scientists proposed the concept of software survival (life cycle) and its waterfall model (Waterfall Model) by referring to the general model of the technical process ). The life cycle of computer software Describes the survival process of software:

Plan: determine the overall goal of developing a software system, and provide its functional, performance, reliability, and interface requirements. Study the feasibility of completing the software task, explore possible solutions to the problem, develop implementation plans for completion of development tasks, and submit the feasibility study report to the Management Department for review.

Requirement Analysis: analyzes the requirements of software development and provides detailed definitions. Compile the Software Requirement Specification and preliminary user manual and submit it to the management organization for review.

Software Design: converts identified requirements into a corresponding architecture. Then, the work to be done by each module is described in detail. Prepare the design specification and submit it for review.

Programming: converts a software design into a computer-acceptable program code.

Software testing: Checks components of the software based on the design test cases.

Operation and maintenance: the delivered software is put into use and properly maintained during operation.

Since the idea of software engineering is introduced, it applies the effective knowledge and methods in other engineering technology research and development fields to the software development work, the solution and specific methods for organizing software development work are proposed based on engineering principles and methods. Software Engineering relieves the "Software Crisis" to some extent ". But the American software scientist F. in his paper, Brooks pointed out that people have not yet found a silver bullet that can defeat the "wolf" (the essential problem of the software crisis) in mythology. Although the problem has been mitigated, the crisis has not been eliminated.

3. Methodology of Software Engineering

In recent years, software engineering has developed the concept of software process. Software Engineering needs to study the "how to do" software method, as well as the supporting software tools and software environment, software Process is to study how to integrate software methods and software tools. In order to better develop and improve software engineering technology, it is necessary for us to analyze the methods, tools, and processes of software engineering from the perspectives of methodology, this improves the ideas, methods, models, and rules of various processes in software engineering.

A. Development of Software Engineering

Like other technical methods, software technology has gone through a historical process from simple to complex, from low to advanced, from experience-based to science-based. Engineering and technical personnel consciously or unconsciously practice this transformation. Looking back on this development history, we can give some helpful inspiration to grasp the essential characteristics of software technology and help promote the development and progress of software technology.

The development phase of software technology can be divided into three phases: the programming stage, which is about 50 to 1960s; the program system stage, which is about 60 to 1970s; the software engineering stage, it is about 1970s years later. The most fundamental changes over the past few decades have been reflected in the concept change: the process has changed from an "art" created by personal intent to an engineering product that can be accepted by the majority of users; the transformation of software from self-sufficiency production methods to circulation in the market to meet the needs of the majority of users; the scope of software work ranges from program writing only to the entire software lifecycle.

With the development of software technology, especially object-oriented technology (OO), software engineering puts forward the following new ideas, methods, and design principles:

Abstract: extract the most basic features and behaviors of a thing and ignore non-basic details. Hierarchical abstraction, top-down, and layer-by-layer refinement are used to control the complexity of the software development process.

Information Hiding: the module is designed as a "black box", and the Implementation Details are hidden inside the module, so that users of the module are not allowed to access the module directly. The principle of separation between use and implementation is used.

Modularization: Information Hiding and abstraction through modular means such as objects and classes helps to express complex systems.

Localization: it centrally logically associates computer resources in a physical module to ensure loose coupling between modules and strong cohesion within the module. This helps control the complexity of the solution.

Certainty: The expressions of all concepts in the software development process should be deterministic, unambiguous, and standardized.

Consistency: consistent concepts, symbols, and terms should be used for each module of the entire software system (including programs, documents, and data.

Completeness: the software system can fully implement the functions required by the system without losing any important components. Strict technical review is required in the software process to ensure system completeness.

Verifiable: developing large software systems requires top-down and layer-by-layer system decomposition. System Decomposition should follow the principles of easy system inspection, testing and review to ensure the correctness of the system.

The practical experience of software technology tells us that decomposition is an effective way to solve complex problems. The decomposition of software problems generally reflects the overall and partial addition and method. "A complex can be established step by aggregating the original separated elements. Otherwise, the features of the complex can be completely divided into the features of each separation element ". Therefore, the problem decomposition following the above design principles can achieve better results.

The development history of software technology also reveals that there are no static methods and no applicable development models. With the research and development of software technology, there must be new and more practical analysis models, design ideas, and development technologies.

B. Technical Software Engineering

Currently, software is recognized as another part of the computer system's dependency on hardware. It is a complete set of programs, data, and related documents. Among them, the program is a sequence of commands executed according to pre-designed functions and performance requirements; data is a data structure that enables the program to manipulate information normally; the document is with program development, maintain and use relevant graphic and text materials. ". The definition of software includes the current understanding of the extension of software technology: all technical means, approaches, and actions are operational rules or patterns in the collection of programs, data, and documents. To analyze software problems from the perspective of methodology, we must consider the characteristics of each software element as a technical method.

Practical: software engineering methods must contain strict practical operation rules or models, rather than theoretical or empty talk. "Symbols are an essential part of the methods that go deep into reality ". Software Engineering must adopt an appropriate symbolic system. Since the end of 1980s, as object-oriented technology has become a hot topic in research, dozens of object-oriented methods supporting software development have emerged. The Unified Modeling Language (UML) integrates the advantages of booch, OMT, and Jacob bson methods to unify the symbol system, in addition, many concepts and technologies that have passed practical tests have been absorbed from other methods and engineering practices to become the Object Management Group (OMG) object-oriented method standards.

Socialization: the software engineering method should focus on social factors, consider issues such as institutions, systems and management methods, and even involve people's ideas and people's psychology. In this field, the Software Engineering Institute (SEI) of Carnegie Mellon University proposed the Capability Maturity Model CMM for software institutions. The CMM is divided into five levels: initial, repeatable, defined, managed, and optimized. CMM defines operable hierarchical implementation and evaluation standards for software institutions from the perspectives of personnel, institutions, systems and management.

Complexity: the software itself is complex. The complexity of the software may come from the complexity of the actual problems it reflects, or the complexity of the logic structure of the program. The software engineering method should take into account how to integrate the knowledge of the application field and how to implement the domain engineering.

C. Systematic Software Engineering

Because the theoretical basis of the computers used today is the Turing machine model proposed by Turing in 1937 and the corresponding von noriman architecture. The idea of a Turing machine is to turn a problem into a mechanical process of solving the problem in a step-by-step manner according to rules. Various computer languages are just some form of language under this idea. Therefore, the process of software development is essentially a process in which programmers form the domain of objective world issues. Programmers first establish the computer language expression of the problem, and finally calculate the result. There is a huge gap between the implementation process (sequential execution) of the Von noriman computer and the process of people's understanding and expression (repeated and gradually deepened, in addition, programmers focus on how to implement and program. The biased understanding and the inertia of thinking lead to insufficient support for the software engineering process. For example, the traditional Waterfall Model Guides the entire development process by means of project phase review and document control, but lacks flexibility and does not take project evaluation and evolution into account.

As an engineering design, the whole process of software engineering process must be considered in a systematic way. Using the idea of the system theory "Dai Ming cycle method", the software engineering process includes four basic process activities and the software survival model:

P (Plan): Software Specification Description. Define the functions and running restrictions of the software;

D (DO): software development. Produce software that meets specifications;

C (check): Software validation. Confirm that the software can fulfill the customer's requirements;

A (Action): Software Evolution. To meet the customer's change requirements, the software must evolve during use.

Evolutionary Model: given that people often do not have a clear understanding of the software requirements at the initial stage of project development, it is difficult for the development project to succeed once, and rework and re-development are inevitable. Therefore, we can first conduct test development, explore feasibility, clarify software requirements, and then obtain satisfactory software products. The first experimental product is often referred to as a "prototype ".

Spiral Model: for complex large-scale software, developing a prototype often fails to meet the requirements. The spiral model combines the waterfall model with the evolutionary model, and adds the risk analysis ignored by both models. The spiral model rotates along the cycle screw line of the "Dai Ming cycle method". A more complete software version is developed after each cycle along the screw line from inside to outside.

Fountain model: the fountain model supports the integration of multiple development activities in software reuse and life cycle, and mainly supports object-oriented development methods. A part of the system often repeats several times, and related functions are added to the evolved system in each iteration. There is no obvious boundary between development activities, that is, analysis, design, and coding.

Intelligent Model: A knowledge-based software development model that combines the above models and expert systems. The model applies a rule-based system and uses a reduction and inference mechanism to help software personnel complete development and maintain the model at the level of system Specification Description.

The evolution model, the spiral model, the fountain model, and the intelligent model take into account the repeated characteristics of people's cognitive expression process, and draw on the systematic method of the system theory, it provides better support for project evaluation and evolution, and organizes various stages of software survival based on application characteristics.

Reference: http://it.icxo.com/htmlnews/2004/08/03/282654.htm