Component-based development of "programming quality" component

Recently read a paper: "ABC: Architecture, component-oriented software developers," Meihong.

This article is mainly about 2 points.

One, what is component-based software development (CBSD).

Second, how to use ABC method for component-oriented software development.

Firstly, component-based software reuse and development is considered to be an effective way to improve the efficiency and quality of software development. As long as there is a complete library of components, the development of software systems can be like stacked wood, the development of the system from programming to component assembly. For example: When the house was built, brick by brick slowly began to base. When the smallest building unit is a wall, such as building a board room, put 4 walls, add a roof is the house, compared to the previous brick by brick, the size of the building becomes larger, the development efficiency and quality significantly improved.

The fundamental idea of ABC method is to use SA theory to guide software development on the basis of component assembly, in order to improve the efficiency and reliability of system generation. Join is one of the important concepts, it explicitly describes the interaction between the components or the interaction protocol. As shown in figure one, the intermediary layer (middleware) is introduced to avoid the complex interaction between components.

Figure 1: The role of the mediation layer

Prior to that, my understanding of artifacts was a separate program that could be reused through encapsulation, like a plugin. In fact, the components and plugins are slightly different. Plug-ins are designed to extend the functionality or performance of the original software, the software that is attached to the original software, based on the interface reserved by the component. components, called assemblies, are more appropriate.

What the heck is a widget. A component is an almost independent, replaceable system component that implements a clear function in a well-defined architecture environment. A component can be a function, a class, a small control, a program, a system (database system, operating system). Component is a complete program body through encapsulation, and for object-oriented design, the minimum package should also be a class. Functions can also encapsulate and define interfaces, but the granularity is too small to be complete enough. component is the combination and encapsulation of a group of classes, hiding the specific implementation (black box), only use the interface to provide services externally.

This paper is about how to develop software for components. I feel like a service-oriented development (SOP) represented by WCF, similar but different. SOP enables complete separation of technology and business, enabling agile, unrestricted information integration. Components originate from within the software industry, and services originate from the needs of users.

Programmers in the development process, always according to the actual needs to determine the development of general-purpose modules or special modules. Similarly, for component development, it is also necessary to consider whether the component needs to be used more than once during the development process to create the component. Reuse component is helpful to improve software quality, improve software development flexibility and standardization degree. But, too much, too keen to reuse to cover all possible situations or potential future needs, it takes a lot of time to design the code. This increases communication costs, maintenance costs, and system overhead. Although large-grained components make software development simpler, higher scrap rate also increases hardware overhead. Therefore, programmers need to use their own experience to determine whether this component is a common function and further separation. But the problem is that there is still no systematic approach and standard to define the guiding development process today.

In addition, the destruction of components is also worth noting. Components can be separated and upgraded, but when there are many systems involved, the modification and destruction of components should also pay attention to the influence of multiple parties. For example, after the destruction, the component is best just mark expiration, prompt the latest method, but not completely deleted. As shown in Figure 2, this method can be compared to Thread.stop () in Java; You can still use it after you discard it.

Figure 2: Deprecated methods

2016, 09, 07