Concept of software architecture

Starting from the software crisis
Software Crisis refers to a series of serious problems encountered during the development and maintenance of computer software. From the end of 1960s to the beginning of 1970s, the term "Software Crisis" was widely used in the computer industry. As a matter of fact, the software crisis emerged almost from the day when computers were born, but it was widely recognized at the International Software Engineering Conference held in garmish in 1968.
1. Performance of Software Crisis
(1) increasing software costs
In the early days of computer development, large-scale computer systems were designed and applied to very narrow military fields. During this period, the cost of computer development was mainly provided by the State Treasury, and the cost was rarely taken into account by the study. With the development of computer marketization and commercialization, cost and cost have become one of the most important issues for investors. In 1950s, software costs accounted for 10%-20% of the total computer system costs. However, with the development of the software industry, software costs are growing. On the contrary, as the technology advances and the production scale expands, the price of Computer Hardware keeps decreasing. In this way, the software cost accounts for an increasing proportion of computer systems. By the middle of 1960s, the proportion of software costs in computer systems had increased to about 50%.
In addition, this number is constantly increasing. The following is a set of data from the U.S. Air Force computer system: in 18%, software costs accounted for about 60% of the total cost, 72% reached in, and reached in, it reached 1980 in 80% and around 1985 in 85%.
(2) difficult to control the development progress
Because software is a logical and intellectual product, software development requires the establishment of a large logical system, which is different from the production of other products. For example, if a factory needs to produce a certain type of machine, it can require workers to work overtime or implement "three shifts" in case of a tight schedule, and none of these methods can be used in software development.
In the software development process, unexpected situations such as user demand changes emerge one after another, making it difficult to implement the software development process as scheduled, it brings great difficulties to project planning and demonstration.
Brook once suggested: "increasing manpower on delayed software projects will only make it more difficult to complete on schedule ". In fact, the structure of the software system is very complex, and the additional links of various parts are extremely great. Increasing the number of software developers blindly cannot increase the software development capability proportionally. On the contrary, as the number of personnel increases, problems in personnel organization, coordination, communication, training and management will become more serious.
Many important large-scale software development projects, such as ibm OS/360 and the world-wide Military Command Control System (wwmccs), consume a lot of manpower and financial resources, we have to announce the failure because it is far from the predefined target.
(3) Poor Software Quality
Even if the software project can be completed by the predefined date, the results are unsatisfactory. From 1965 to 1970, the launch of a rocket at the fantenburg base in the United States failed many times. Most of the failures were caused by applications. Program Error. Some minor program errors can cause catastrophic consequences. For example, one time, a rocket was launched at Kennedy, the United States, and the rocket began to flip dozens of miles above the ground, the ground control center was forced to order the destruction. After inspection, we found that the flight plan program missed a hyphen. Such a small omission has led to the failure of this $18.5 million Rocket test.
In the "software Workshop", due to the lack of guidance of engineering ideas, programmers almost always habitually use their own ideas to replace users' requirements for software. The software design is random, A lot of functionality is just a programmer's "wishful thinking", which is an important factor in making software unsatisfactory.
(4) difficult software maintenance
There are always a certain number of errors in the software officially put into use. under different operating conditions, the software will fail, so maintenance is required. However, due to the fact that the software development standards are not strictly followed during the software design and development process, there is a great deal of randomness and there is no complete record document that truly reflects the system status, it creates great difficulties for software maintenance. Especially in the process of software use, the original developers may have left the original Development Organization for various reasons, making the software almost impossible to maintain.
In addition, software modification is a "dangerous" task. For a complicated logical process, even a small change may introduce potential data to indicate that, the cost paid for maintenance software in the industrial sector accounts for 40%-75% of all hardware and software costs.
2. Causes of Software Crisis
The reason for the software crisis can be found from the various manifestations of the software crisis and the particularity of the software as the logic product:
(1) Unclear user requirements
In the software development process, unclear user requirements are mainly reflected in four aspects:
◇ Before the software is developed, the user does not know the specific requirements of the software;
◇ The user's description of the software requirements is not accurate, and there may be omissions, ambiguity, or even errors;
◇ In the software development process, users also propose requirements for modifying software functions, interfaces, and supporting environments;
◇ The understanding of user requirements by software developers is different from that of users.
(2) lack of correct theoretical guidance
Lack of strong methodological and tool support. Because software is different from most other industrial products, its development process is a complex logical thinking process, and its products depend heavily on the high intellectual investment of developers. Being overly reliant on the skills and creativity of programmers in the software development process, increasing the personalization of software products is also an important cause of the software crisis.
(3) growing software scale
With the increasing application scope of software, the scale of software is growing. Large software projects need to be organized with a certain amount of manpower. Most managers lack experience in developing large software systems, while most software developers lack management experience. Information exchange between various personnel is not timely, accurate, and sometimes misunderstood. Software Project developers are prone to omissions and errors because they cannot effectively and independently process all the relationships and branches of large software.
(4) Increasing software complexity
Software not only expands rapidly in terms of scale, but also increases complexity dramatically. The particularity of software products and the limitations of human intelligence lead to weakness? Quot; complex problem ". The so-called "complex problem" concept is relative. Once people adopt advanced organization forms, development methods and tools, the efficiency and capability of software development are improved, new, bigger, and more complex problems are in front of people.
3. How to overcome the software crisis
After carefully studying and analyzing the real causes behind the software crisis, people come to the conclusion that "people are not only facing technical problems, but more importantly, management problems. Poor management will inevitably lead to failure. "Conclusion, we began to explore the possibility of using engineering methods for software production, that is, using modern engineering concepts, principles, technologies and methods for computer software development, management and maintenance. So software engineering, a new field of computer science and technology, was born.
Software Engineering is the development and maintenance of computer software based on engineering, scientific and mathematical principles and methods. Software Engineering includes three elements:
(1) method. The software engineering method provides the "how to do" Technology for software development, and is the technical means to complete the software engineering project;
(2) tools. Software tools are the extension and extension of human intelligence and physical strength during software development activities, providing an automatic or semi-automatic software supporting environment for software engineering methods;
(3) process. The software engineering process is to combine software engineering methods and tools to achieve reasonable and timely computer software development.
So far, the research and application of software engineering have made great achievements, and its application in software development methods, tools, management and other aspects has greatly eased the passive situation caused by the software crisis.
Reuse of components and software
1. Software Reuse
Software reuse refers to the process in which identical or similar software elements are repeatedly used in two or multiple different software development processes. Software elements include programs Code , Test cases, design documents, design processes, requirement analysis documents, and even domain knowledge. Generally, this reusable element is called a software component. The larger the reusable software element, the larger the granularity of reuse.
Using software reuse technology can reduce a large amount of repetitive work in software development activities, which can improve software productivity, reduce development costs, and shorten the development cycle. At the same time, because most software components have undergone strict quality certification and are verified in the actual operating environment, reusing software components helps improve the software quality. In addition, software flexibility and standardization are expected to be improved when software components are widely used.
Here, we briefly introduce the concept and function of software reuse technology for the convenience of the subsequent articles. Software reuse is a profound and profound technology. Interested readers can refer to relevant materials and books.
2 component
It is generally considered that a component is a unit software with complete semantics, correct syntax, and reusable value. It is a system that can be clearly identified during software reuse. In terms of structure, it is a combination of semantic descriptions, communication interfaces, and implementation code. Simply put, a component is a program that has certain functions and can work independently or be assembled with other components to coordinate the work. The use of the component is independent of its development and production. From the abstract level, the object-oriented technology has reached the class-Level Reuse (code reuse), which is a unit of class encapsulation. Such reuse granularity is too small to solve heterogeneous interoperability and higher efficiency reuse. A component refers to a higher level of abstraction. It encapsulates a group of classes and represents a specific service that completes one or more functions, it also provides users with multiple interfaces. The entire component hides the specific implementation and uses only interfaces to provide services.
In recent years, the component technology has developed rapidly and has formed three major schools: IBM's CORBA, sun's Java platform, and Microsoft's COM +.
If you consider a software system as a collection of components, the components that constitute a system can be divided into five categories:
(1) Independent and mature components. Independent and mature components have been tested multiple times in the actual running environment. These components hide all interfaces and users only need to use the specified commands. For example, database management systems and operating systems.
(2) Restricted components. Restricted components provide interfaces and indicate the conditions and prerequisites for use. Such components may have resource conflicts, overwrites, and other impacts during assembly. They must be tested during use. For example, the base class library in various object-oriented programming languages.
(3) Adaptive components. Adaptive components are packaged or interface technologies are used to handle incompatibility, resource conflicts, and so on. Such components can be used in various environments without modification. For example, ActiveX.
(4) assembled components. When installing components, they are already assembled on different levels of the operating system, database management system, or information system. They can be connected using blue code. Currently, most software products provided by some software vendors belong to this category.
(5) modifiable components. Modifiable components can be replaced by versions. If the original component is modified incorrectly and new features are added, you can use the "Wrap" or write interface to replace the component. This type of component is widely used in application system development.
Component-based software development usually includes component acquisition, Component Classification and retrieval, component evaluation, adaptive modification, and assembling existing components into a new system in a new context. Component acquisition can be implemented in different ways:
(1) obtain qualified components from existing components and directly use or make adaptive modifications to obtain reusable components;
(2) extract components with potential reuse value from heritage projects to obtain reusable components;
(3) purchase commercial components from the market, that is, COTS components;
(4) Develop new conforming components.
When making the above decisions, an enterprise or organization must take into account the one-time cost of component acquisition in different ways and the future maintenance cost to make the best choice.
3. Software Architecture
1. The rise of software architecture
Since the software crisis in 1960s, people began to pay attention to the research of software engineering. At first, people put the focus of software design on data structures and Algorithm As the software system grows and becomes more complex, the structure and specifications of the entire system become more and more important. The degree of the software crisis is increasing, and the existing software engineering methods are insufficient. For large-scale complex software systems, the design and specification of the overall system structure has become much more important than the selection of computing algorithms and data structures. In this context, people recognize the importance of software architecture, it also believes that the system and in-depth research on the software architecture will become the most promising way to improve software productivity and solve software maintenance problems.
Since the software system was first divided into many modules, modules interact with each other, and the combination has an overall attribute, it has an architecture. Good developers often use some architecture patterns as software system structure design strategies, but they do not express their knowledge in a standardized and clear way, so that they cannot communicate with others. The software architecture is the further development of design abstraction, meeting the needs of a better understanding of software systems and more convenient development of larger and more complex software systems.
In fact, software always has an architecture, and there is no software without the architecture. The term architecture stands for "architecture" in English. Software is compared to a building because it has basic, main, and decoration, it is the infrastructure software on the operating system, the main application that implements the computing logic, and the user-friendly interface program. From the details, every program is structured. Early structured programs form a module composed of statements. The clustering and nesting of modules form a program structure called by layers, that is, the architecture. The consistency of the Program (expression) structure and (Computing) logic structure of the structured program and the top-down development method naturally form the architecture. In the era of structured program design, the program scale is not large. by emphasizing the structured program design methodology, we can gradually refine the process from top to bottom, and pay attention to the coupling of modules to obtain a relatively good structure, no particular research on software architecture was conducted.
We can make a simple analogy. In the era of structured program design, brick, tile, gray, sand, stone, prefabricated beams, columns, roof panels, bungalows and small buildings are built, in the object-oriented era, the construction of high-rise buildings is built with integral walls, whole rooms, and pre-built parts on one floor of stairs. How can components be properly matched? How can the architecture be constructed easily? After the important components have been changed, how can we ensure that the entire tall building will not fall down? What components are required for each application field (hospitals, factories, hotels )? What are the practical, beautiful, powerful, and cost-effective component frameworks that allow the built buildings (that is, the architecture) to better meet user needs? Just as civil engineering has entered modern architecture, software has also moved from traditional software engineering to modern object-oriented software engineering, and has studied the architecture of the entire software system, it seeks to construct the fastest, lowest cost, and best quality construction process.
Although the software architecture originated from software engineering, its formation also draws on many valuable ideas and methods in the computer architecture and network architecture, in recent years, software architecture research has been completely independent of Software Engineering Research, and has become a new research direction and independent branch of computer science. The main content of software architecture research involves software architecture description, software architecture style, software architecture evaluation, and software architecture formal method. Solving the reuse, quality and maintenance of software is the fundamental purpose of studying the software architecture.
2. Definition of software architecture
Although the software architecture has been widely used in the software engineering field, so far there is no widely accepted definition. Many experts and scholars have characterized the software architecture from different perspectives and different aspects. Typical definitions include:
(1) Dewayne Perry and a1ex wo1f once defined that a software architecture is a structured element with a certain form, that is, a set of components, including processing components, data components, and connection components. The processing component processes the data. The data component is the information to be processed. The connected component connects different parts of the architecture. This definition focuses on distinguishing processing components, data components, and connection components. This method is basically maintained in other definitions and methods.
(2) Mary Shaw and David Garlan think that the software architecture is a layer in the software design process, which goes beyond the algorithm design and data structure design in the computing process. Architecture issues include the overall organization and global control, communication protocols, synchronization, and data access, assigning specific functions to design elements, the organization, scale, and performance of design elements, select among various design schemes. Issues concerning the design and description of the overall system structure above the software architecture processing algorithm and data structure, such as global organization and global control structure, and protocols for communication, synchronization, and data access, design component Function Definition, physical distribution and synthesis, selection, evaluation and implementation of design schemes, etc.
(3) kruchten points out that the software architecture has four perspectives: They are described from different aspects of the system: the main components of the system and their relationships are described from the conceptual perspective; the module angle includes functional decomposition and hierarchy; the running angle describes the dynamic structure of a system; the Code angle describes the organization of various codes and library functions in the development environment.
(4) Hayes Roth considers the software architecture as an abstract system specification, including the interconnection, interfaces and relationships between functional components and components described by their behaviors.
(5) David Garlan and dewne Perry adopted the following definition in the IEEE software engineering paper in 1995: A software architecture is the structure of various components of a program/system, the relationships between them, the design principles, and guidelines for evolution over time.
(6) Barry Boehm and his students proposed that a software architecture includes a set of software and system components, interconnection and constraints, and a set of system requirements description; A basic principle is used to describe this component. Interconnection and constraints can meet system requirements.
(7) In 1997, bass, ctements, and kazman gave the following definitions in the book "using software architecture: the software architecture of a program or computer system includes the visible characteristics and relationships of one or more software components and the software components. Among them, "visible features outside the software" refers to the service, performance, features, error handling, and shared resource usage provided by software components.
In short, the research on software architecture is developing, and the definition of software architecture must be improved accordingly. In the future Article If not specifically stated, we will use the following definition of the software architecture:
The software architecture provides a high-level abstraction of the structure, behavior, and attributes of the software system, it consists of the description of the elements that constitute the system, the interaction of these elements, the mode for guiding element integration, and the constraints of these modes. The software architecture not only specifies the organizational structure and topology of the system, but also shows the correspondence between system requirements and elements that constitute the system. It provides the basic principles of some design decisions..