“Software Development with Objects, Agents and Services” By Michael N. Huhns Comments by Antonio Castro on Michael N. Huhns paper (19th of July of 2005)
Starting from the final section of this paper one can see that the main focus is on “Consensus Software” - a way of enabling individuals to participate more directly in the behavior of their governing institutions. Nowadays “applications are beginning to span enterprises with autonomous components” and “the web is making possible for individuals to make available not only information but also behavior”. At the same time “work on semantic web is making it possible for mutual understanding to be reached among autonomous components”. Section 2 of this article presents the advantages and disadvantages of several programming methodologies, including: Procedural, Object-Oriented, ComponentBased, Agent-Oriented and Multiagent-Oriented. It ends with a summary table where concepts like Abstraction, Building Block, Computation Model, Design Paradigm, Architecture, Modes of Behavior and Terminology, are compared between Procedural, Object and Multiagent-based/Service-oriented languages. In section 3 we have an introduction to SOC –Service Oriented Computing and the problems that SOC tries to address. At the same time defines the focus on “how to build software out of agents, i.e., agents as the fundamental building blocks for software, rather than how to engineer agents per se or how to use agents to help construct software, i.e., agent-bases CASE tools”. Section 4 is devoted to SOC, the advantages, additional benefits and imposed requirements. The section ends with an interesting conclusion saying that “Ideas similar to SOA were developed in MAS literature. (…) SOC adds to MAS ideas is the ability to build on conventional information technology and do so in a standardized manner so that tools can facilitate the practical development of large-scale systems”. Section 5 tells us how to engineer SOC applications saying that, basically, “it is a process of discovering and composing the proper services to satisfy a specification, whether the specification is expressed in terms of a goal, a workflow (tasks), or some other model”. However, there are several challenges regarding transport, messaging and security constraints, which must be handled for each collaboration. In this section the author also points out some problems that need to be solved: • •
•
The existence of a basis for standardizing and automating the behaviors that are expected of the participants in a B2B transaction. Misbehaviors must be handled. “For example, a precise specification of a purchase order does not say what to do in the following case: if a company does not receive a response, should it assume that the recipient was not interested or that the PO was lost?” Organization of services in the repository. Nowadays the services within a repository are not organized.
Software Development with Objects, Agents and Services by Michael N. Huhns
Antonio Castro reflection number 1: The Web Services exposes services through methods and attributes in a XML document. It is necessary to find a way of “understand” automatically the meaning of this information and the semantic meaning of the service, that is, the semantic of the services and their attributes/methods. Ontologies and an inference engine it’s a possible way of doing this and it could be the job of an agent. We could use some techniques of Meta-Learning to solve this problem, like the k-NN Ranking Method. We could consider a repository of Web Services Meta-Data and, given a specific service we are looking for, characterize that service in terms of Meta-Data and, according to the k-NN ranking method, receive a recommended ranking of existing web services to use. A mandatory characteristic of the meta-data has to be an excellent semantic definition of the web service. Section 6 of the article starts to talk about the Consensus Software, that is, the approach proposed by the author. The author starts to say that “the two most needed research advancements for service-oriented computing are”: 1. Investigate how mutual understanding can be reached among autonomous entities. 2. Investigate how consensus behavior among agents with overlapping interests can be achieved. The author is investigating these within the context of constructing conventional software out of agent-based components. The author hypothesis the following: 1. Redundancy: Robust software can be achieved through redundancy where the redundancy is achieved by agents that have different algorithms but similar responsibilities. 2. Widespread development: Redundant algorithms can be obtained through the efforts of many people outside of the traditional software development community. It will be required tools, an infrastructure and a means for semantic reconciliation. The rest of the article analyzes the relationship between the software systems that manage and control societal institutions and the members of the society. Starts with two facts: 1. Consensus Software can be internally coherent and comprehensible because it can make use of the consensus ontologies they are developing. 2. A software-component industry is arising that will distribute on demand components that have functionality customized to a user’s need. There are also some questions to be answered and problems to be solved: •
How can component providers be confident that their components will behave properly? The answer is on agent-based components that actively cooperate with other components to realize system requirements or a user’s goal.
Comments by Antonio Castro on Michael N. Huhns paper
2/5
Software Development with Objects, Agents and Services by Michael N. Huhns
•
•
•
Distributed active-object architecture is required: Each application executes as a set of geographically distributed parts. Objects taking part in the application most likely were developed in various languages and executed on various hardware platforms. A simple, powerful paradigm is needed for communications among these heterogeneous objects. The answer: Agent-based Web Services. There must be an infrastructure to enable the discovery of pertinent objects: Because the identities of the resources are not known when the application is developed. Once an object has been discovered, the infrastructure must facilitate the establishment of constructive communication between the new object and existing objects in the application, which can be satisfied by the agent-based web Services. The workflow should be explicitly represented and available to both the application and the user: The pattern of interaction among the objects (workflow) is a critical part of the application and may vary over time. When an object has been discovered to be relevant to an application, the language for interaction and the pattern of interaction with the object must be determined. This interaction becomes part of the larger set of object interactions that make up the application. The objects collaborate with each other to carry the application task.
Antonio Castro reflection number 2: Michael Huhns seems to be reflecting about a society of agents in a large scale, where an agent, after arriving to that society, could identify other agents to help him in realizing the tasks he has to fulfill. A lot of questions regarding security and the way of doing it arise from this moment on. In section 6.1 there is an interesting point of view that is “as societies attempt to coordinate and control their members use of utilities and resources, individuals should have a means to influence the coordination and control based on their preferences. … Decisions can be made centrally or collectively when a system is dynamic so that decisions must be made in real-time, individuals would benefit from active systems that could intercede on their behalf. Examples of such institutions are banking, distributing electricity, controlling traffic, etc.” Antonio Castro reflection number 3: The concept of democratization in software it’s something important to explore: to leave the centralized perspective and allow the users express their preferences. For this view to be possible it is necessary to define objectives and constraints and, then, let the users express themselves. In the crew-scheduling problem, for example, this would allow the crewmembers to express their choice for the monthly crew roster. The objective would be to have Active Systems that, after learning the user’s preferences, could intercede on behalf of the user, when the decision has to be made. In section 6.2 Designing and Engineering Agents and according to the author, the most investigated and applied agent-oriented methodologies are: Agent UML, MASCommonKADS and GAIA. The first two are extensions of previous software engineering design processes and the last one was developed specifically for agent modeling. Others are AAII, MaSE, Tropos, Prometheus and ROADMAP.
Comments by Antonio Castro on Michael N. Huhns paper
3/5
Software Development with Objects, Agents and Services by Michael N. Huhns
Section 6.3 is about bugs, errors, redundancy and robustness. Redundancy is the basis for most forms of robustness. It can be provided by replication of hardware (for example, in the cockpit or a commercial airplane, some of the instruments are replicated, some of them with different technology), software, information and by repetition of communication messages. The basis for robustness: software components with equivalent functionality so that if one fails to perform properly, another can provide what is needed. Antonio Castro reflection number 4: In my thesis I’m thinking in using different agents that try to solve the same problem using different algorithms. Using this approach I can increase the robustness of the application and, if I use good criteria, I will have the opportunity to choose the best one among the several solutions. This should not follow the strict rule of m agents * n functions. Instead, it should be adapted to this specific subject. How much redundancy? If a system provides n functions robustly, we must introduce m * n agents, so that there will be m ways of producing each function. Each group of m agents must understand how to detect and correct inconsistencies in each other’s behavior, without a fixed leader or centralized controller. Of course that redundancy should be balanced with complexity which is determined by the number and size of the components chosen for building a system. In Section 6.4 the author speaks about Consensus Ontologies and how to Model Objects, Resources and agents. To enable agents to interact productively, each agent construct and maintain models of each other but, if there are n entities in the environment then we have to maintain n(n1)/2 models. How to solve this problem? The agent should presume that unknown agents are like itself, and it should choose to represent them as it does itself. Thus, an agent learns more about other agents, it only has to encode any differences that it discovers. The main criteria used by an agent to decide if it can contribute to a new problem are the relative importance of each feature (dimension) of the problem, the degree of similarity with the agent’s capabilities and an estimate of the agent’s capabilities relative to other agent’s capabilities. Percepts and interactions are messages received from and sent to other agents. Agents are rational in the context of all other agents in their organization or institution, because they are aware of the other agent’s constraints, preferences, intentions, and commitments and act accordingly. In this scenario there is a problem: How can the information from large number of such sources be associated, organized and merged? The author believes that it is not necessary a global ontology but that any pair of ontologies can be related indirectly through a semantic bridge consisting of many other previously unrelated ontologies, even when there is no way to determine a direct relationship between them. The author proposal is a methodology that relies on sites that have been annotated with ontologies. The domains of the sites must be similar but they will have dissimilar ontologies, because they will have been annotated independently. When two agents communicate they must reconcile their semantics and this will be seemingly impossible if their ontologies share no concepts. However, if their ontologies share concepts with a third ontology, then the third ontology might provide a semantic bridge to relate all Comments by Antonio Castro on Michael N. Huhns paper
4/5
Software Development with Objects, Agents and Services by Michael N. Huhns
three. Note that agents will only relate the portions of their ontologies necessary to respond to the request and not their entire ontologies. The difficulty in establishing a bridge will depend on the semantic distance between the concepts and on the number of ontologies that comprise the bridge. The author methodology is appropriate when there are large numbers of small ontologies. The last section (6.3) is about Agents-Based web Services. Agent architectures have many of the same features as Web Services: provide yellow-page and white-page directories, where agents advertise their distinct functionalities and where other agents search to locate the agents in order to request those functionalities. However, agents extend Web Services in the following ways: • • • • •
A web Service knows only about itself, but not about its users/clients/customers. Agents are often self-aware, and gain awareness of the capabilities of other agents as interactions among the agents occur. Web Services, unlike agents, are not designed to use and reconcile ontologies. If a client and provider of a service have different semantics, the result of invoking the service would be incomprehensible. Agents are inherently communicative, whereas Web Services are passive until invoked. Agents can provide alerts and updates when new information becomes available. A Web Service is currently not autonomous. Agents are cooperative, and by forming coalitions can provide higher-level and more comprehensive services.
As an example of the use of agents-based Web Services, let’s suppose that an application needs simply to sort some data items and suppose there are five Web sites that offer sorting services described by their input data types, output date type, time complexity, space complexity, and quality: one is faster, one handles more data types, one is often busy, one returns a stream of results, while another returns a batch, and one costs less. An application could take one of the following possible approaches: • • • • •
The application invokes services randomly until one succeeds. The application ranks services and invokes them in order until one succeeds. The application invokes all services and reconciles the results. The application contracts with one service after requesting bids. Services self-organize into a team of sorting services and route requests to the best one.
The last two require that the services behave like agents. Furthermore, the last two are scalable and robust, because they take advantage of the redundancy that is available.
Comments by Antonio Castro on Michael N. Huhns paper
5/5
