PACT: an experiment in integrating concurrent engineering systems
TL;DR: The Palo Alto Collaborative Testbed (PACT) as mentioned in this paper is a concurrent engineering infrastructure that encompasses multiple sites, subsystems, and disciplines, including NVisage, a distributed knowledge-based integration environment for design tools; DME (Device Modeling Environment), a model formulation and simulation environment; Next-Cut, a mechanical design and process planning system; and Designworld, a digital electronics design, simulation, assembly, and testing system.
Abstract: The Palo Alto Collaborative Testbed (PACT), a concurrent engineering infrastructure that encompasses multiple sites, subsystems, and disciplines, is discussed. The PACT systems include NVisage, a distributed knowledge-based integration environment for design tools; DME (Device Modeling Environment), a model formulation and simulation environment; Next-Cut, a mechanical design and process planning system; and Designworld, a digital electronics design, simulation, assembly, and testing system. The motivations for PACT and the significance of the approach for concurrent engineering is discussed. Initial experiments in distributed simulation and incremental redesign are reviewed, and PACT's agent-based architecture and lessons learned from the PACT experiments are described. >
Citations
More filters
TL;DR: This paper describes a mechanism for defining ontologies that are portable over representation systems, basing Ontolingua itself on an ontology of domain-independent, representational idioms.
12,962 citations
01 Dec 1995-International Journal of Human-computer Studies \/ International Journal of Man-machine Studies
TL;DR: The role of ontology in supporting knowledge sharing activities is described, and a set of criteria to guide the development of ontologies for these purposes are presented, and it is shown how these criteria are applied in case studies from the design ofOntologies for engineering mathematics and bibliographic data.
Abstract: Recent work in Artificial Intelligence is exploring the use of formal ontologies as a way of specifying content-specific agreements for the sharing and reuse of knowledge among software entities. We take an engineering perspective on the development of such ontologies. Formal ontologies are viewed as designed artifacts, formulated for specific purposes and evaluated against objective design criteria. We describe the role of ontologies in supporting knowledge sharing activities, and then present a set of criteria to guide the development of ontologies for these purposes. We show how these criteria are applied in case studies from the design of ontologies for engineering mathematics and bibliographic data. Selected design decisions are discussed, and alternative representation choices and evaluated against the design criteria.
6,949 citations
TL;DR: Agent theory is concerned with the question of what an agent is, and the use of mathematical formalisms for representing and reasoning about the properties of agents as discussed by the authors ; agent architectures can be thought of as software engineering models of agents; and agent languages are software systems for programming and experimenting with agents.
Abstract: The concept of an agent has become important in both Artificial Intelligence (AI) and mainstream computer science. Our aim in this paper is to point the reader at what we perceive to be the most important theoretical and practical issues associated with the design and construction of intelligent agents. For convenience, we divide these issues into three areas (though as the reader will see, the divisions are at times somewhat arbitrary). Agent theory is concerned with the question of what an agent is, and the use of mathematical formalisms for representing and reasoning about the properties of agents. Agent architectures can be thought of as software engineering models of agents;researchers in this area are primarily concerned with the problem of designing software or hardware systems that will satisfy the properties specified by agent theorists. Finally, agent languages are software systems for programming and experimenting with agents; these languages may embody principles proposed by theorists. The paper is not intended to serve as a tutorial introduction to all the issues mentioned; we hope instead simply to identify the most important issues, and point to work that elaborates on them. The article includes a short review of current and potential applications of agent technology.
6,714 citations
[...]
TL;DR: In this approach to software development, application programs are written as software agents, i.e. software “components” that communicate with their peers by exchanging messages in an expressive agent communication language.
Abstract: The software world is one of great richness and diversity. Many thousands of software products are available to users today, providing a wide variety of information and services in a wide variety of domains. While most of these programs provide their users with significant value when used in isolation, there is increasing demand for programs that can interoperate – to exchange information and services with other programs and thereby solve problems that cannot be solved alone. Part of what makes interoperation difficult is heterogeneity. Programs are written by different people, at different times, in different languages; and, as a result, they often provide different interfaces. The difficulties created by heterogeneity are exacerbated by dynamics in the software environment. Programs are frequently rewritten; new programs are added; old programs removed. Agent-based software engineering was invented to facilitate the creation of software able to interoperate in such settings. In this approach to software development, application programs are written as software agents, i.e. software “components” that communicate with their peers by exchanging messages in an expressive agent communication language. Agents can be as simple as subroutines; but typically they are larger entities with some sort of persistent control (e.g. distinct control threads within a single address space, distinct processes on a single machine, or separate processes on different machines). The salient feature of the language used by agents is its expressiveness. It allows for the exchange of data and logical information, individual commands and scripts (i.e. programs). Using this language, agents can communicate complex information and goals, directly or indirectly “programming” each other in useful ways. Agent-based software engineering is often compared to object-oriented programming. Like an “object”, an agent provides a message-based interface independent of its internal data structures and algorithms. The primary difference between the two approaches lies in the language of the interface. In general object-oriented programming, the meaning of a message can vary from one object to another. In agent-based software engineering, agents use a common language with an agent-independent semantics. The concept of agent-based software engineering raises a number of important questions.
2,373 citations
Book•
30 May 1997
TL;DR: The design of and experimentation with the Knowledge Query and Manipulation Language (KQML), a new language and protocol for exchanging information and knowledge, which is aimed at developing techniques and methodology for building large-scale knowledge bases which are sharable and reusable.
2,223 citations
References
More filters
TL;DR: This article presents a vision of the future in which knowledge-based system development and operation is facilitated by infrastructure and technology for knowledge sharing, and describes an initiative currently under way to develop these ideas.
Abstract: Building new knowledge-based systems today usually entails constructing new knowledge bases from scratch. It could instead be done by assembling reusable components. System developers would then only need to worry about creating the specialized knowledge and reasoners new to the specific task of their system. This new system would interoperate with existing systems, using them to perform some of its reasoning. In this way, declarative knowledge, problem- solving techniques, and reasoning services could all be shared among systems. This approach would facilitate building bigger and better systems cheaply. The infrastructure to support such sharing and reuse would lead to greater ubiquity of these systems, potentially transforming the knowledge industry. This article presents a vision of the future in which knowledge-based system development and operation is facilitated by infrastructure and technology for knowledge sharing. It describes an initiative currently under way to develop these ideas and suggests steps that must be taken in the future to try to realize this vision.
1,640 citations
Proceedings Article•
01 Jan 1992
TL;DR: Knowledge Interchange Format (KIF) is a computer-oriented language for the interchange of knowledge among disparate programs that has declarative semantics and logically comprehensive semantics.
Abstract: Knowledge Interchange Format (KIF) is a computer-oriented language for the interchange of knowledge among disparate programs. It has declarative semantics (i.e. the meaning of expressions in the representation can be understood without appeal to an interpreter for manipulating those expressions); it is logically comprehensive (i.e. it provides for the expression of arbitrary sentences in the rst-order predicate calculus); it provides for the representation of knowledge about the representation of knowledge; it provides for the representation of nonmonotonic reasoning rules; and it provides for the de nition of objects, functions, and relations.
1,017 citations
TL;DR: The need for a massive knowledge base spanning human consensus knowledge is examined and the authos' efforts over the past five years to begin its construction are reviewed.
Abstract: Cyc is a bold attempt to assemble a massive knowledge base (on the order of 108 axioms) spanning human consensus knowledge. This article examines the need for such an undertaking and reviews the authos' efforts over the past five years to begin its construction. The methodology and history of the project are briefly discussed, followed by a more developed treatment of the current state of the representation language used (epistemological level), techniques for efficient inferencing and default reasoning (heuristic level), and the content and organization of the knowledge base.
507 citations
01 Jan 1992
TL;DR: The framework is designed to support information sharing and coordinated communication among members of a product development organization, particularly for the tasks of design knowledge capture, dynamic notification of design changes, and active management of design dependencies.
Abstract: Information sharing and decision coordination are central problems for large-scale product development. This paper proposes a framework for supporting a knowledge medium (Stefik 1986): a computational environment in which explicitly represented knowledge serves as a communication medium among people and their programs. The framework is designed to support information sharing and coordinated communication among members of a product development organization, particularly for the tasks of design knowledge capture, dynamic notification of design changes, and active management of design dependencies. The proposed technology consists of a shared knowledge representation (language and vocabulary), protocols for foreign data encapsulation and posting to the shared environment, and mechanisms for content-directed routing of posted information to interested parties via subscription and notification services. A range of possible applications can be explored in this framework, depending on the degree of commitment to a shared representation by participating tools. A number of research issues, fundamental to building such a knowledge medium, are introduced in the paper.
249 citations