Program Mining: Implementation of Active Services

views updated

Chapter 4
Program Mining: Implementation of Active Services


As mentioned in Chapter 3, Active Services mean to enhance Web Service with the functions of recognition and processing of user requirements, so as to allow users to select a proper function set according to specific requirements, construct new services and applications according to needs, and subsequently enable the Internet, primarily equipped with the capability of “Services-On-Demand.”

Besides Web technology, the implementation of Active Service relies on the following three theories and technologies: component technology, agent technology, and data mining technology.

Component-technology-supported software entities can be stored in the nodes of the Internet in an open and self-contained way, which form the re-organizable and reusable component resources on the Internet. The appearance, accumulation, and development of the resources on the Internet, greatly improve the capability of “Services-On-Demand” of the Internet and lay a solid program foundation for Active Services.

The development of agent technology enables the program module to possess self-learning and memorizing ability. Multi-agent technology and the corresponding supporting platform also boast the capacity of coordination and decision-making among agents. This makes it possible to implement intelligent distributing computing in the Internet environment. Most functions of the Active Service can be implemented through agents.

When users put forward service requests, if Web Services do not offer corresponding supports, the Active Service system will construct a new service to meet the user requirements by recomposing and reusing the components. It needs to search for components that can meet corresponding functions from the Internet or the component base. The theory and method of data mining provide the foundation for mining and searching for the components on the Internet.

Based on the above theories and methods, we propose a new technology, Program Mining, as the implementation of Active Services. Program Mining first classifies, organizes, and stores the components from the Internet. When users put forward their requests, the program mining system analyzes and identifies the requests, and retrieves existing components to see if there are components satisfying these user requests, If there are none, the request will be subdivided, and the system goes on to search for and compose components according to subdivided requests.

How to get, organize, analyze, and mine the components on the Internet conveniently is the subject of program mining technology. The basic idea of program mining is: using multi-agents to analyze user requirements, then recognizing, finding, and getting the required components and composing them automatically from the vast resource of components on the Internet, then forming the program that can meet user requirement, and finally submitting the program to the user in the service-providing manner.

In this chapter, we will first introduce the relevant concepts about program mining, then define program mining, and finally examine the process of program mining and its main, related research topics.



Mcllroy, an expert from Bell Lab, put forth the idea of “Software Assembly Line” first in his thesis of “Mass Produced Software Component” in the Software Engineering Conference of NATO in 1968. Since then, component technology, being one of the key technologies for software reuse, has been preferred by software researchers. Along with the development of the Internet, components have been uploaded to the Internet, and become the basis of implementation of Active Service.

  1. Concept of Components. Components are reusable software modules with independent functions. They are based on the object-oriented technique, but they are different from objects. Compared with objects, components have better encapsulation—all the programming details are encapsulated inside the components and only reusable interfaces are provided to the outside. Meanwhile, the granularity of components is more coarse and emphasizes the integrity of functionality. Some components are integrated applications by themselves.
    Components have similar roles in software designs with integrated circuit (IC) modules in electronic designs. They conceal concrete realization of functions and provide strictly defined interfaces to the outside. Therefore, components are aptly called “software ICs.” They have the following features:
    • independently published software module;
    • encapsulation of specific functions through strictly defined interfaces;
    • support plug-and-play in the component framework;
    • support collaboration and composition with other components to form a software system;
    • can be replaced by other components that implement the same interface.
  2. Standards of components. To support software reusable technology, many organizations and companies successively put forward their own component standards. At present, the most influential component standards include Sun's Java component standard JavaBean/EJB, Microsoft's standard COM/DCOM and Object Management Group (OMG)'s CCM standard in CORBA 3.0. They are introduced here briefly:
    1. JavaBean. JavaBean is a Java-based component technology specification released by Sun Microsystems in September 1996. It integrates component technologies with the Java language. On the basis of this specification, the developers can make Java components independent of operating system platforms.
    2. EJB (Enterprise Java Bean). EJB was published by Sun Microsystems in March 1998. It defines the server-side component interfaces of development, configuration, and management, and allows the user to reuse the server-side components to develop large-scale business applications. At present, a lot of companies, including Oracle, Borland, Tandem, Symantec, and Sybase, have declared their support for EJB in their respective products.
    3. CORBA Component Model (CCM). CCM was voted and passed by relevant work groups of the Object Management Organization in August 1999. It is an important part of the CORBA 3.0 Specification, which defines the component framework for creating, composing, and publishing of plug-and-play CORBA objects.
    4. COM/DCOM. COM/DCOM is a component specification put forward by Microsoft, which is a binary standard, and neither designates the component implementation language nor restricts component realization methods. It aims at improving the efficiency and security of remote component access with the provision of the optimized remote calling mechanism and authorized accessing mechanism.
  3. An example of component programming. In the following, we will discuss an example of component applications on the realization of ATM operation functions. There are three components relating to ATM operation requirements: ATMGUI, Transactions, DBProcess. They, respectively, accomplish the ATM interface, ATM business processing, and updating account information in the database in the ATM transaction. We use the UML physical view to illustrate the three components. The components are expressed in the form of a large rectangle with two smaller rectangles on one side, and the circle connected to them refers to the component interfaces. The physical view of the three components can be elaborated as follows:
    1. Component ATMGUI (Figure 4.1)
      Name: ATMGUI
      Function: Input transaction information of ATM customer Interface: None
      Context: Call the Transactions component, deliver the transaction information, and display the transaction result.
    2. Component Transactions (Figure 4.2)
      Name: Transactions
      Functions: Receive transaction requests from the ATMGUI component, implement the transaction and store the data by calling the DBProcess component.
          Interface 1: Account_Check verify the password of user account

              Parameter: Name username input by customer
                              Password password input by customer
              Return Value: Success success or not in user password verifying
          Interface 2: Trans_Call transact the user's transaction request
              Parameter: Trans_type types of transaction (deposit, inquiry, etc.)
                              Trans_content content of transaction
              Return Value: Trans_result the result of service processing
      Context: Receive callings from ATMGUI, and call DBProcess to store transaction information
    3. Component DBProcess (Figure 4.3)
      Name: DBProcess
      Function: update account and transaction information in the database
          Interface 1: Update accept calling from Transactions component
              Parameter: SQLstr string of database operation
              Return value: DB_result results of database operation
      Context: accept the call from Transactions component
    The calling context among the three components is depicted in Figure 4.4, where the broken line arrows refer to the calling relationship. An integrated application of ATM Transaction is generated conveniently through composition of these three components.As shown in Figure 4.4, the three components have independent functions, and they interact with each other through their unified interfaces. We may observe from the example above that.
    1. The function of any component is independent. If the inner implementation of one component changes, there is no change, in other components, so long as the interface is not changed. For instance, in the example above, if there is any improvement inside the Transactions component, other components do not necessarily make any changes.
    2. The components can be developed with different programming languages, such as VB, C/C. The components can work well together, so long as they conform to a unified component specification.
  4. Component resources on the Internet. Conforming to the standards of the component mentioned above, people have developed a lot of components and set up professional component libraries on the Internet as reusable resources. These component libraries, respectively, store JavaBean, EJB, ActiveX, COM, and DCOM components for querying, browsing, and even downloading. The following is a brief introduction to the component resources of major component libraries on the Internet:
    1. ComponentSource (
      ComponentSource was established by a group of software engineers in 1995. It mainly provides the publishing and sales information of various components. As the biggest online component market, ComponentSource has over 9000 registered components. These components are classified in three major ways: according to component types (products by type), component platforms (products by platform), and component functions (products by function). In the function classification, ComponentSource adopts the single-layer classification method to directly classify components into over 100 classes. Thus, it is easy to find the specific component by the function conditions and other restrictions, such as the model, the platform, and so on.
    2. Flashline (
      Flashline was created by Charles Stack in 1998. It stores about 800 components in its resources library, including JavaBean, EJB, ActiveX, and COM. The components in Flashline are organized according to the category of double-layer structure. First, the components are divided into ten categories: Communications, Development Tools, IDE Extensions, Information Management, Internet/WWW, Network, Science, Training, User Interface, and Utilities; then, each class is subdivided into more subcategories. In Flashline, the component description consists of introduction, comments, supporting information, which offers a brief description of component function, and application environment.
    3. ComponentPlanet (
      Harrison founded ComponentPlanet in 1999, which provides nearly 1000 different components, organized using the method of multifacets. Each facet represents a sorting viewpoint—for instance, programming language, component model, and application domain. Under the given facet, the components are subdivided into more subclasses. Therefore, by combining various facets, the user can quickly find the required component. The product descriptions are very detailed, including function description, test document, version information, component regulation, interface information, application enviroment, installing guide, and so on. Furthermore, ComponentPlanet assigns a short number to each component, which consists of three parts. The user may track the component items via the component number, binary revision number, and archives revision number. Thus, when a customer has to replace the damaged copies, he/she can trace out the exact version. Then, this short number is bound with the object into the component relation model. In this way, the customer can recognize the different features, such as, whether one component relies on another or whether it must work with other components and so on.
    4. Alphaworks (
      Alphaworks is a free component library maintained by IBM. It provides JavaBean and other components in beta version for the purpose of finding defects in component design. Through users' testing and feedbacks, the component will be improved gradually until it meets the requirements of a normally released product. The components enlisted in Alphaworks have been tested many times by developers and they are provided with a detailed user guide and development document, some of them even with the source code, which makes these components very valuable in analysis and reusing. Just because of this, Alphaworks has become one of the most important JavaBean libraries on the Internet. At present, this library can provide about 560 JavaBean components. They are sorted and organized separately by function, group name, component name, JDK version, updated time, release date, and so on.
      These component libraries form the component resources on the Internet. With the development of component techniques, there is a continuously expanding online component library on the Internet. It forms a solid base for component-based program development.


Agent is a new software technique. The main idea is that by giving the software system intelligence of some degree, it automatically performs some tasks without human intervention and improves the work efficiency. Generally, an agent is regarded as a software entity that is able to perform some independent operations, without the help of a user or other agent, to fulfill the given task. An agent has the following intelligent features:

  • Autonomous. The agent can run self-determinedly without human or system interference, and possesses the capability of controlling its behavior and inner state.
  • Cooperative. Agents can communicate with each other at an application layer, share knowledge and be an organic integer, so as to complete the users' complex task.
  • Reactive. The agent is able to sense or monitor the changes in the surroundings, and reacts properly in time.
  • Proactive. The agent can operate proactively according to the desired goal, rather than merely passively echoing the instruction from the surroundings.
  • Task-oriented. The agent can process complex and high-level tasks, can divide the task into many subtasks and fulfill them one by one.

With the development of network techniques, an important feature of the agent is moving among network nodes freely—this kind of agent is called a mobile agent. It can move freely in the running environment of the network node. The mobile agent can arrive at a certain computer, which stores information or service, collects information, and executes the operation, then comes back to the source computer after fulfilling the tasks. The mobility of agent improves the flexibility of the agent and shows obvious advantages in many application fields.

The mutual communication among agents facilitates sharing of knowledge, division and cooperation of work, and coordination with each other. As a result the agents form an organic integer to help the user to fulfill some more complex tasks. Such a kind of multiple-interactive-agent-based system is commonly called a multi-agent system (MAS). Generally speaking, in a multi-agent-system, there are mobile agents as well as common static agents, and they possess the same domain knowledge. And based on domain knowledge and agent communication language (ACL), the agent can realize the high level interaction and coordination. At present, people have developed various MASs and they are widely used in the fields of work flow controlling, Computer Supported Cooperative Work (CSCW), network management, information retrieval, electronic business, and so on.

The rapid development of the Internet has spurred users to apply the agent technique to Web fields. Intelligent agents help the user finish the tasks, such as information searching. Intelligent agents can also be used in application program and services mining, helping the user/system make the requirement analysis, component searching, communication, and management.


Along with the rapid development of database technologies and wide application of database systems, much progress has been made in data mining technologies and systems, which enables users to find concealed knowledge from mass data. They have been applied in the Web field. Data mining technologies have been used to help users to search for, find, and acquire information on the Internet. The Web field-based data mining technologies are generally referred to as Web mining technologies.

According to actual objects, Web mining technologies are classified into three types, which are Web content mining, Web structure mining, and Web usage mining. Web content mining refers to tapping the methods of

induction-based learning, machine-based learning, and statistics-based learning to discover and pick up information of interest to the user and higher levels of knowledge and rules from the mass of Web sites. Web structure mining is based on WWW organization and hyperlink structure to analyze the hypertext structure of files, inner structures of files, and URL directory structure for network navigation and network information induction. Web usage mining is used to analyze log files of Web servers to discover the browsing patterns of users in accessing networks, so as to supply Website managers with various information that facilitates Web site improvement and the creation of economic benefits.

Although each mining forms have different objects to deal with, they have applied identical technological scheme, which include the following steps:

  1. Data preparation. Web mining processes a large amount of data, which includes Web page contents, Web site structures, and Web site access records. Prior to Web mining, it is necessary to carry out operations such as: data selection—selecting related data; purification—eliminating noises and redundant data; deduction—reckoning missed data; conversion—switch of discrete data and successive data, data grouping and classification, and calculating combination and decrement—reducing data size, so as to transform texts, graphics, and other files on Web pages into forms applicable for the data mining calculating method.
  2. Pattern Recognition. Pattern Recognition is the most crucial step in Web mining. It applies technologies such as decision tree, classification, clustering, rough set, associate rules, neural network, and genetic algorithms to select corresponding calculating parameters, analyze data, and to reach mode models for likely knowledge.
  3. Evaluate and interpret model. Evaluate and analyze the knowledge model as acquired from user experiences, determine the meaningful models and rules, examine the accuracy with data, and present the models to users in an easily understood manner.
  4. Consolidate knowledge. With knowledge mode models, there is still a demand for coherence examination, to settle conflicts with other mode models and consolidate knowledge.
  5. Apply knowledge. There are two methods to apply knowledge. One is to handle the relations and results as described with the knowledge itself to offer support for decision-making, optimize network designs, and upgrade system performances. The other is to predict problems according to the acquired knowledge and rules.

The component technology, agent technology, and data mining technology discussed above have laid a foundation for Active Services and program mining.


There are a number of reasons for program mining, and they are discussed below.

First, as mentioned above, user requirements on the Internet are changing with the personalized and comprehensive trend, but Web services cannot provide users with personalized and integrated services. All services on the Internet are program-based execution processes. In other words, a service is a kind of computation, demanding the support of a certain program. Therefore, both personalized service and integrated service need support by certain programs. As for personalized services, we have to develop a large number of various programs to meet the various personalized requirements. But due to the development rates of computer software and hardware technology, system costs, or quality and number of software programmers, it is unlikely that so many programs can be made.

Second, users have more and more requirements for the current Internet Services, having increasingly higher expectations of the Internet. These new requirements on the Internet are eventually satisfied by new services, so there is more and more need of new services. How do we respond to such requirements for new services from users? Web Services supporting platforms, such as Microsoft.Net and SunONE, have provided a lot of tools and middleware to help service developers develop new services. But, it isn't an efficient mode to satisfy user requirement using only these tools and middleware platforms.

Third, Active Services can provide personalized and integrated service to the user, but feasible methods to implement Active Services are still needed. Software reuse is obviously an effective method to reduce programming and save computer system software and hardware costs. There are many kinds of software reuse. The library function call is the earliest and most normal method, which is to make frequently-used programs into software packages according to given standards and norms, so users can use them in programming. The problem with such a method is that these software packages must depend on certain programming languages (such as C, C++ and certain programming environments (such as Visual C++ compiler). Therefore, this kind of reuse is only for software programmers. Another software reuse

method is the object-oriented method, which has improved upon the base of the library function call method in terms reusing software ideas and scope. But it is still a reuse tool for software developers and programmers. Therefore, although the library function call method and the object-oriented method may cut down the software programmers burden, it is unlikely to support user-oriented Active Services on the Internet.

The emergence of components (including the Web Services) brings new ideas for software reuse. Through them, users can create their own applications according to their requirements. As described in Section 4.1.1, components provide a base for implementing Active Services on the Internet. However, how does one find the component that can fulfill user requirements? Where are these components? How does one use, organize and manage these components after they are found? Are components of different specifications and norms compatible with and convertible to each other? These are problems to be faced and solved in constructing Active Services with components.

Program mining is proposed to implement Active Service in the Internet environment. It analyzes the functionality of service, and searches for, finds and organizes the existing components that meet the user requirements according to user's service requirements. To decrease the user's programming burden and improve the efficiency of searching, we should mine, organize, and classify the component resources beforehand. We manage them with a certain specification and standard and generate the component resource library/warehouse for the user. Meanwhile, when users use these components in the warehouses to construct new active services, if the components cannot meet user requirements, or the component warehouses are short of corresponding components, the program-mining system should record user requirements, and mine the components deeply on the Internet or request component developers to develop new components.



Program mining is a technology about searching and mining components published on the Internet according to user requirements. It also refers to organizing, classifying, storing, identifying, discovering, and searching for components according to given specifications and standards, thus decreasing programming workload and implementing Active Services.

To implement Active Services, program mining should analyze and understand user requirements, and organize and manage components obtained from the Internet in a unified manner. Therefore, a program mining system should contain at least the following parts:

  • Interface for program mining. This module implements the communication and interaction between the user and the program mining system. It is used to input user requirements, provide help information and return related program mining results.
  • Requirements analysis module. This analyzes user requirements, and maps user's input to the component system.
  • Component search engine. The search engine includes two parts, one part searches for and mines component resources from the Internet and stores them in the component warehouse, the other retrieves components from the component warehouse.
  • Component composing and verification engine. This module composes and executes retrieved components and constructs new components and services.
  • Component warehouse. This module facilitates storage, organization, and management of components obtained from the Internet in a unified manner.

The general process of program mining is shown in Figure 4.5. The users computing request is submitted to the program mining server by the intelligent agent and the human–machine interface. The program mining server analyzes the requirements and decomposes functions to generate query conditions for searching components, searches the components satisfying query conditions

in related component libraries, and then tries to find the component composition that can meet user requirements according to component dependent and calling context relations. Finally, the program mining system composes the components into an executable program and runs it to provide active services.


The process of program mining can be divided to two parts. One part is searching, mining, and retrieving component resources from the Internet, and creating and expanding the local resource library. The other part is searching and picking up components that can meet user requirements, and composing and executing those components. The workflows of these two parts are shown in Figures 4.6 and 4.7.

In Figure 4.6, intelligent agents or searching tools search and mine new components from the Internet periodically. These components could be professional components in a professional component resource warehouse, or the components that are published and verified by the programmer on the Web, or the components that are published on the Web only for online use, which cannot be downloaded. If new components are found, intelligent agents and search tools could download the components, which include component entity and corresponding description information, according to the agreement between the component resource warehouse and Websites. If new components are non-downloadable online components, the related functional description and the related URL will be downloaded.

Because components have diversified formats and types, for example, JavaBean and ActiveX have completely different component formats, there might arise demands to share components of different formats and from different developers when reusing them. Therefore, we need to convert the description of components of different formats or developed by different developers into a Universal Component Description Language (UCDL). It facilitates sharing of components between different formats and developers, and makes it possible to convert user service requirement into recognizable searching and querying conditions.

After converting the format component descriptions and recording the Web address of online components, components and their descriptions, or the online component's web address, are stored to Local Component Resource Warehouse (LCRW) in a given organized structure. To increase the searching speed and system security, the local resource library could be organized in a distributed manner.

After constructing the local component resource warehouse, the user can request a service from the system according to needs; the process is shown in Figure 4.7.

First, the user inputs service requests with given user interfaces. After that, the system records related information of the user requesting services. If such a service has already existed, i.e., it does not need to be processed further, then the system will automatically call the related service entity to satisfy user requests. If the needed service does not exist, the system or component search engine will run user requirement analysis modules to analyze user requirements and decompose them into subfunctions. In the process of requirement analysis and function decomposing, the system also uses XML language to describe service requests and related functions, so as to extract the keywords list and functional sequence table needed for component retrieving and composing. According to the keywords list, the component searching engine can search for the components that match the given keywords from LCRW. If such components do not exist, it will return searching

failure information. If more than one component can match the given keywords, the component searching engine returns the related functional descriptions to the user. It is up to users to decide which one can best fit their service. If the user thinks that the obtained components cannot meet their needs, then they can modify the service request input, allowing the system request analysis and function decomposition to better fit the given functional sequence in component function decomposing. The system then composes the components to a new component. This component will be stored to LCRW after being verified. Meanwhile, the desired new service can be acquired when the component is executed.


Program mining is a very complex system engineering. It is related to multiple subjects and fields including artificial intelligence, software engineering, database and network, etc. Therefore, scientific and technological problems in these subjects or fields have much relevance to program mining.

However, in terms of mining components and implementing Active Service on the Internet, program mining places particular emphasis on organization, classification, management, storing, reorganization, discovery, and searching of components, as well as software reuse and active service implementation.


The research on user requirement description mainly focuses on recognizing, understanding, function analyzing, and decomposing of user input information, and also on how to convert user input to formalized description.

User input modes are diversified. For example, audio, video, text and icon navigation are all commonly used input methods. When one user inputs audio data, the system is confronted with the problem of voice recognition and nature language understanding. Voice recognition and natural language understanding are long-term research subjects in the field of artificial intelligence, for which many existing techniques can be used. The program mining system mainly focuses on how to apply these techniques in program mining processes. In order to convert user inputs to computer-recognizable and processable symbols, the system can apply the voice recognition and natural language understanding techniques to analyze user inputs in natural languages (such as Chinese and English, in general, limited to finite application domain), and then convert them into the keywords that are described by unified specification and format, as well as the sequence relations of keywords.

Many formalized description languages, including Specification and Description Language (SDL) and Language Of Temporal Ordering Specifications (Lotos), can be used to describe these keywords. We use XML language to describe keywords and their sequence relations, because XML is compatible with Web Service and easy to process.

We will elaborate on user requirement descriptions and human–machine interface designs of program mining in Chapter 5.


There are many professional component libraries on the Internet, such as Alphaworks, ComponentPlanet, ComponentSource, and Flashline. These component libraries provide components that are in different formats and developed by different companies, such as JavaBean/EJB, COM/DCOM, and CORBA. But since these components are different in organizational structure, component descriptions, access methods and formats, they cannot be called and shared by each other. For example, JavaBean components cannot work with ActiveX components, and CORBA components cannot work with COM components. Therefore, it is very important to solve the calling problem among different components in program mining.

Dou et al. (2004) propose the UCDL (Universal Component Description Language) methods, which can solve the calling problem among heterogeneous components. It includes component model, structures, presentation methods, and mapping methods among CORBA, JavaBean, and ActiveX.

The UCDL protocol covers the difference in component descriptions and calling interfaces by encapsulating components, so as to implement the universal accessing of components. It describes the static attributes, function classification, and component functionality by defining related component models, thus making it convenient for upper layer applications to search for and obtain components. It adopts a programming-language-independent interface specification to describe the interface behavior of components, and uses XML to express related information. UCDL can also help the exchanging and processing of such information and inter-operation with other systems.

We will give a detailed description of UCDL and its interfaces in Chapter 6.


How does one organize and manage the components that are searched from the Internet in different formats and from different companies? This is another topic of interest in program mining. We use the UCDL specification

to construct a LCRW with unified structure, and manage and organize the components according to specified organizations and structures.

We will present a detailed introduction to the organization, management, of component resources in Chapter 7.


The task of component composing is to assemble the components that are found into a new program, which can meet user requirements according to the function sequence of components on the basis of requirement analysis.

After composing, the program mining system should verify and publish the mined results. The system may publish the results to LCRW or the Internet platform, or may also directly download the composed programs to the client side according to user selection. The composed program runs and fulfills the user's task.

We will discuss the component composition and program publication in Program Mining in Chapter 8.


How to apply the intelligent agent technique in the program mining process is another important topic. In the process of program mining, the intelligent agent technique is used in the learning of the user input process, the searching/mining components from the Internet, and the communicating and unified access between heterogeneous components.

Making use of the intelligence, autonomy, and mobility of intelligent agents, the program mining system can analyze user's computing demands, rapidly and effectively search for the required components, automatically compose components, and verify the resulting program. In this way, by the cooperation of multi-agents, all the modules of the program mining system can work together to smoothly complete the program mining and the customization of Active Services.

We will give a detailed description of the application of intelligent agents in program mining in Chapter 9.


The study of online component searching and mining involves a series of topics, including locating and accessing the professional component warehouse

on the Internet, locating and accessing online and offline components on Web sites, and downloading and recognition of function description information, etc. At present, we assume that the Internet addresses of professional component warehouses are all known. Besides, we may download components from numerous Web sites and professional component warehouses to construct local component resource warehouses in a kind of manual manner.

We will elaborate on online component searching and mining in Chapters 7 and 10.


Bellavista, P., Corradi, A., et al. (2003). Dynamic binding in mobile applications.IEEE Internet Computing, 7(2), 34–42.

Ben-Shaul, I., and Kaiser, G. (1998). Coordinating distributed components over theInternet. IEEE Internet Computing, 2(2), 83–86.

Bertrand, M., and Christine, M. (1999). Component-based development: from buzz to spark. IEEE Computer Magazine,July.

Beugnard, A., Jezequet, J.M., Plouzeau, N., and Watkins, D. (1999). Making components contract aware. IEEE Computer Magazine,July.

Damiani, E., Fugini, M.G., and Bellettini, C., (1999). A hierarchy-aware approach to faceted classification of object-oriented components. ACM Transactions on Software Engineering and Methodology, 8(3), 215–262.

Dou, Y. H., Zhang, Y. X., and Li, X. (2004). An XML-based software component description method for program mining. Chinese Journal of Electronics, 13(1), 100–104.

Gorton, I., and Liu, A. (2003). Evaluating the performance of EJB components. IEEEInternet Computing, 7(3), 18–23.

Grady, H., and Campbell Jr. (1999). Adaptable Components. (ICSE 1999). Los Angeles, CA: IEEE Press.

Guedes, L. A., Oliveira, P. C., and Faina, L. F. (1998). An agent-based approach for supporting quality of service in distributed multimedia systems. Computer Communications, 21, 1269–1278.

Gunopulos, D., Ljardpm, R., Mannila, H., and Toivonen, H. (1997). Data mining hypergraph transversals and machine learning. (PODS 1997). Tucson, Arizona, USA: IEEE Press.

Hayes, C. C. (1999). Agents in a nutshell—a very brief introduction. IEEE Transactions on Knowledge and Data Engineering, 11(1), 127-132.

Maurer, F., and Dellen, B., et al. (2000). Merging project planning and Web enabled dynamic workflow technologies. IEEE Internet Computing, 4(3), 65–74.

McFall, C. (1998). An object infrastructure for Internet middleware, IBM on component broker. IEEE Internet Computing, 2(2), 46–51.

Meyer, B. (2001). Microsoft.NET is coming. IEEE Computer Magazine, August.

Mezini, M., and Lieberherr, K. (1998). Adaptive plug-and-play components for evolutionary software development. OOPSLA'98 10/98 Vancouver, B.C.

Milojicic, D. S., Laforge, W., and Chauhan, D. (1998). Mobile objects and agents(MOA). Distributed System Engineering, 5, 214–227.

Nwana, H. (1996). Software agents: an overview. The Knowledge Engineering Review,11(3), 205–244.

Pitt, D. H., and Freestone, D. E. (1990). The derivation of conformance tests from LOTOS specifications. IEEE Transactions on Software Engineering, 16(12), 1337–1343.

Port, D., and Kaiser, G. (1998). Collaborative technologies for evolving software systems. IEEE Internet Computing, 2(6), 79–83.

Rosenberg, D. (1998). Bringing Java to the enterprise: Oracle on its Java server strategy. IEEE Internet Computing, 2(2), 52–59.

Seacord, R. C., Hissam, S. A., and Wallnau, K. C. (1998). AGORA: a search engine for software components. IEEE Internet Computing, 2(6), 62.

Steel, C. M. (2002). Building a multisite Web architecture. IEEE Internet Computing,6(5), 59–66.

Voas, J. M. (1998). Certifying off-the-shelf software components. IEEE ComputerMagazine, June.

Wei, Z. Z., Zhang, Y. X., and Li, X. (2001). A new computing paradigm: program mining. FTC 2001, Nov. Beijing.

Zhang, Y. X., Peng, M. T., and Zhang, Y. (1994). SDL_TRAN: an interactive generator for formal specification language SDL. Computer Research and Development, 31(11), 44–49.

Zhang, Y. X., Wang, X. C., and Zhao, Y. B. (1999). Computer Network and InternetTutorial. Beijing: Tsinghua University Press.