Toward component-oriented (programmer) _ Enterprise applications

This article is from "Programmer" magazine, fourth 2005, "Huangliuqing" column.

Introduction

--------------------------------------------------------------------------------

Software has always been a young, technology-driven industry. In the early days, software was a subsidiary of computer hardware systems. At that time, the hardware is the main body of the computer, the software is only to help the hardware to do "work" some instructions. The way the software is expressed is also very hard. There was a machine that looked like an old-fashioned typewriter, but instead of typing the characters on a piece of white paper, it put holes in the cardboard. A piece of the program is like using three poker like a tractor, a thick stack of OH.

Although have C + +, Java, EE,. NET and ubiquitous Internet applications, although the software is not only a self-contained industry, and its prosperity even more than hardware (hardware progress too fast, but lost people's concern and respect. , but the nature of the software has not changed: software is a description of hardware computing, each high-level software statement more or less corresponding to a number of machine instructions.

With the increasing infiltration of software systems and the increasing volume of business systems, the problems are becoming more and more serious. Now an enterprise application, often involves every part of the enterprise, will be written by dozens of people hundreds of thousands of to millions of lines of code to complete. On the other hand, the modern enterprise is in a constantly changing dynamic environment of survival and development, therefore, enterprise applications need to be constantly maintained-that is, partially rewrite some of the existing software. By hundreds of thousands of millions of code-type change factors, composed of the changing system, its complexity is not seen in human history. The security and quality reliability of software often become a serious problem in modern ubiquitous and omnipotent information system.

Perhaps, we can put aside the machine instruction plot that is always held when the computer is born.

Perhaps we don't need to know bytes, pointers, and threads.

We can envision new enterprise software systems from the perspective of business business from the perspective of functional specifications.

component-oriented and related enterprise component Bus technology (see Figure 1), it is a long time in the academic circle, the corporate world has been grinding the sword for ten years. Component-oriented technology integrates traditional component technology, model-driven technology and service-oriented technology, and it is a fixed Poseidon needle in software industry. We are pleased to present in this column a series of topic-oriented theory and practice outlines that are becoming popular in the world.

What is a widget.

--------------------------------------------------------------------------------

In the software industry, the term "widget" is one of the most frequently used and ambiguous concepts. For example, it can be used for user interface artifacts such as ActiveX or Java beans, for important architectures such as database management systems, and for all reusable software.

The component we are talking about here refers to a piece of software that is self-contained and has a clear interface (or a group of). At the same time, we also implied that the component should have clear run-time and on-line connotation. That is, the widget has an interface that is accessible to the runtime, and at some point in the software development lifecycle, the widget can be delivered and installed independently. In addition, we also require that a component can be easily merged or combined with other artifacts to provide useful functionality--typically, a single component works in concert with other artifacts to achieve its effectiveness.

A widget is an object that can be inserted into a system. Since they are objects that can be inserted, there must be an object for them to insert. The difficulty of the software component lies not only in the need to know how to establish a clear interface, self-contained, useful software, but also to ensure that when applying a suitable component, there is a corresponding socket to use. For example, a kettle is a component of the kitchen. If it needs 500V power and five-pin sockets to work, then the kettle is useless. Of course, we can make a special transformer for the kettle, but that's too impractical. It can be seen that the technical undertaking for component insertion is as important as the interface provided by the component.

When considering artifacts, we sometimes care too much about component technology and forget about the user of the widget. In fact, the design component must take into account a certain class of users with certain skills (but often rarely noted). For example, some artifacts are intended for use by developers, while others are intended for use by end users.

In general, we can state the software component model with four elements: the component itself, the socket of the component, the ability of the component to collaborate with other components, and the user of the component (see Figure 2).

1. Component is a self-contained software structure, it has a specific purpose, with a run-time interface, can automatically on-line, and before the establishment of the specific components of the socket.

2. Component sockets are software that provides a well-defined, well-defined run-time interface for a supporting architecture that must be adapted to the architecture. It is necessary to have a design-time interface, but not enough, because the interface does not exist at run time unless there is another software to implement it, that is, there is another schema to implement it.

3. A component is built to work together with other components.

4. The component sockets and corresponding components are designed for certain users with certain skills and tools. With regard to the last point, we should also take note of the following two questions:
Component users may not have the skills or tools necessary to establish the widget. This means that component products are layered, so that someone's final product may become a component of others.
It is often not possible to establish a corresponding socket-architecture-to fit the widget while building the widget.

In addition to the basic elements mentioned above, the enterprise component should have the following two features in the enterprise level application level that we are concerned about:
Meet enterprise-level challenges. Such artifacts, when conceived, clearly address the challenges of enterprise-level distributed systems, including parallel processing, security, transaction management, database access, and many more.
They "represent some kind of business concept in a single form." These artifacts are not a bunch of code with an ambiguous meaning, they represent the corresponding business concepts in the information system.

What is component-oriented software development.

--------------------------------------------------------------------------------

Component-oriented development is a software development tool, which is based on components in different stages and different aspects of the development cycle, including requirement analysis, structure, design, establishment, testing, on-line, support technology architecture, project management, etc.
This definition extends the extension of component-oriented development from the application of component-oriented thinking to the whole software development cycle-all phases and all aspects are component-centric. If you want the widget to be ready for assembly at any time, the artifacts must be built as part of the project, and the component-oriented aspect is particularly advantageous. Indeed, although these artifacts are not yet available, the idea of using component methods to conceive information systems is still the best way to control the complexity of the development of large distributed systems.

The necessary condition of component-oriented software production
At present, the main goal of any mature industry is to establish efficient production capacity. For software, we call such an efficient software production capacity "Software Factory". Based on the mature component-oriented software industry features, we can infer that for a "flexible software component Factory", the following are the prerequisites:
It is important to reduce the "manufacturing costs" of software development by significantly reducing development, online, personalized costs, and the evolution of large high-performance and scalable systems. In other words, our focus is not only on analysis-design-developing this lifecycle, but on the entire lifespan of the SOFTWARE PRODUCT.
Must be able to respond quickly to changes in "business needs" and "technological changes". Must be able to deal with the specific needs of a vertical area or a particular customer in the form of "order production". Must be able to deliver "highly personalized" and "configurable" products and processes.
Must be able to support the establishment of both "highly modular" and "highly integrated" software. These two terms may sound contradictory, but they are not: software artifacts must have well-defined boundaries and belong to an explicit structure.
There must be a "standard" for the specification and interaction of components, with both technical and functional guidance.
Assuming these necessary conditions are met, efficient factories exist, and the benefits of component-oriented development in such a factory can be listed.


Benefits of component-oriented software production
Past We think that component-oriented is a very comprehensive tool in software manufacturing. It covers all aspects of software development: from conceiving and producing individual components, to economically assembling components into systems or joint systems, and the evolution of these systems and federated systems. As a means, the component is built on the basis of all the most successful technologies, principles and past best practices, which results in a software development theory and practice involving large software production and its industrialization support. The component not only retains the advantages of all the means in the past, but also solves its limitation while including object-oriented method and distributed object method.
Can control the complexity of development. At present, the leading mechanism uses this method in the development of large-scale system, and uses it to control the complexity and risk of the project with the features of structure-centered and reusable. The component-oriented method is a perfect way to divide the business domain. Component-oriented components can control the complexity generated by assembling large scale systems, rather than building these artifacts.
Changed the nature of information systems. Perhaps the most important point comes down to far-reaching relevance, which causes fundamental changes in the nature of software-or the nature of application. It fundamentally shakes the concept, and we need to redefine the application. At run time, the widget becomes highly visible, which affects how software is built, assembled, online, tested, evolved, marketed, and marketed. Component-oriented development is not only a means of development, but also a means of on-line, which leads to new ways of marketing and software solutions to purchase.
To make autonomous development parts possible. Building information systems in a way that is similar to autonomous units can support a new and challenging opportunity for highly parallel development, testing, and online. Challenges come from different layers of architecture, and the concepts that autonomous components need to truly implement parallel development are also useful.
Can control the complexity of the on-line. Organizing the entire development process around the component is an effective mechanism to reduce the complexity and cost of all stages of development. This cost reduction effect is even more pronounced during the evolution of the system, as a large number of system changes or fixes only affect a component.
Covers all aspects of development. Component-oriented development can be achieved by using the same set of refined unified concepts in all aspects of development, similar to the following: For example, a distributed component within an enterprise and its continuity can be defined by this method, which enables both database modeling and component modeling, so long as there is no material separation between the two, the same set of principles can be applied.
Covers the entire software lifecycle. The component-oriented theory focuses on and takes into account the whole software lifecycle. It not only covers a very important development cycle, but also covers the maintenance, on-line, personalized work. The whole software supply chain is influenced and simplified by the component-centric approach. We even like to use component-oriented ideas to write user manuals and online help.
Shorten the time to market. A mature component-oriented development will significantly reduce the time required for software development before it goes public. This is especially true when working with widget frameworks and component-oriented templates. It makes it efficient and easy to assemble new systems with off-the-shelf components, reducing the development time to the extent that we today seem to be unbelievable.

Component-Oriented Architecture

--------------------------------------------------------------------------------

To know any complex things, we should adopt the way of divide and conquer and then synthesize. We understand the component-oriented architecture from the following three aspects.

The computational level of the component
Computer science is a subject of computational automation. Therefore, it is a natural thing to study the component-oriented theory based on the component as the basic computational unit in the perspective of computational hierarchy.
According to the different computing levels, we can divide the components into: Page component, display logic component, business process component, business logic component, Operation logic Component, data component and so on. It is worth noting that the application of internet-based enterprises should be paid enough attention, which is also reflected in the classification of components.

The system level of the component
We also need to look at the system level of the component, because we want to have a larger granularity of "building blocks" so that the component-oriented advantages can be maximized. The system level of component includes: component interface, component, component package, component subsystem, component system, component library and so on.
In our opinion, it is very practical to classify the components from the computational hierarchy and the system level respectively-they depict the responsibilities of the component and the reuse granularity of the component (see Figure 3).


Building a component-oriented software factory

The component-oriented development process does not create the so-called "Bai Mafima" myth, it contains elements and generalized software development process elements are not essential differences, are covered by the requirements, modeling, design, development/assembly, testing and so on. So, where is the development process of the component before it? Since all phases are based on artifacts, each step of the process can benefit from the "building block" approach to work. When this kind of "building block" software factory affected the software establishment, after assembling, on-line, testing, evolution, marketing, and sales, no one will deny that the component-oriented concept fundamentally shakes the concept of software development after it has been completely subverted by the way software is marketed and how software solutions are purchased. The concept of engineering is not entirely appropriate, and re-engineering is a better way to reflect the reality of the software industry vocabulary.
Of course, to build a component-oriented software factory, it is not enough to have a thorough understanding of the component-oriented theory system and the component-oriented development process, we must also use the component-oriented technology support system and the power of the component-oriented application system architecture.
As mentioned earlier, the extension of component-oriented development has been increasingly extended to all aspects of software development. For example, modeling, assembly, development, debugging, publishing, deployment, running, and managing environments, and so on, will be impacted by component-oriented concepts. And it is the component-oriented technology support system, which provides the powerful support of "factory-class" For the dream of component-oriented development. Taking modeling as an example, the promotion of productivity by the current model-driven development has been widely accepted by the industry, and the component-oriented technology integrates the model-driven lever into the "visual Creation" and "visual assembly" of components. It can be said that the "combination effect" of model-driven and component-oriented integration greatly simplifies the working mode of the component factory and improves the productivity.
The rapid change in business and technology can only be seen as a threat to be prevented, but it also brings great opportunities. The Enterprise component Bus technology is a sword that has been honed by the corporate in the past 10 years, which is essentially a kind of micro-kernel architecture model. The micro-core architecture model is for "Coping with Change", and the component-oriented technology support system will not ignore it, but it should be implemented as one of the core thoughts of "embracing change", and the Enterprise component bus is a concrete embodiment.
The architecture of component-oriented application system is supported by the technical support system of component-oriented technology. For example, technologies such as data bus, Message Queuing, service-oriented, model-driven, and fat-thin clients all perform well in the architecture of component-based application systems.

Summary of component-oriented architecture

To sum up, in order to fully understand the component-oriented architecture, we must make a thorough investigation from many angles (see Figure 4).
In this paper, we discuss the system level of component, the computing level of component, and the construction of component software factory in three aspects. It is worth noting that these three aspects are orthogonal relations, the isolation of any one to replace the overall understanding of the component-oriented, are biased.


Component oriented to mature

--------------------------------------------------------------------------------

In recent years, many factors are contributing to the maturity of component-oriented technology.
Looking at the "ecological environment" of commercial enterprises, the future will become more and more unpredictable, which is one of the most challenging aspects of the new economy. And the old technology can not meet the commercial enterprise "on demand," the demand, the trend is declining.
On the other hand, software technology has developed rapidly and matured in recent years. For example, architecture technology and framework technology to deal with the complexity of the software itself, such as the latest development of the AOP technology as divide and conquer, such as the Web Service technology of distributed computing, more than the effort to promote the development of the abstract level of model-driven technology, and so on.
Business is also very active, component-oriented integration platform has been introduced, and its operational support system is also changing.
In a word, due to the maturity of software technology, the existing technology of enterprise application can not meet the demand, and the generalization of component-oriented integration platform and operation support System, the component-oriented software factory is becoming mature.

Author Introduction:
Huangliuqing, founder of the General Software company, director and Chief Technical Officer (CTO). It is an expert and forerunner in the field of component-oriented.