|
|
Page Title | ||||||||||||||||||
| Intelligent OOP | ||||||||||||||||||
|
Multi Agent Objet Level Computing The Priliminary Overview Cyrus F. Nourani Abstract We present new OOP techniques called Multi Agent Object Level Programming, and new paradigms for OOP defining intelligent objects. New linguistics constructs are defined for object level programming with String and Splurge functions treating object visibility and messages. Treating objects as abstract data types and a two level programming approach to OOP allows us to define Pullup abstractions to treat incompatible objects. The techniques open new areas of research on object level programming to pursue, and put us at MJOOP, the Multiagent Junction For OOP. The project fills the gap between object programming as languages and their artificial intelligence practice. Keywords Abstract Objects, Intelligent Syntax, MJOOP, Multi Agent Object Level Programming, Multi Kernel Design With OOP Copyright © Photo reproduction for noncommercial use is permitted without payment of royalty provided that the Journal reference and copyright notice are included on the first page. 0. Introduction We present new techniques and languages for object level programming with intelligent trees implemented by agent functions. We have defined intelligent syntax and put forth the basis for automatic tree implementation techniques for object level programming. We define OOPI, OOP Intelligent, functions and Pullup Abstractions in brief from our [5,6] as a structural analogy to operation overloading. New linguistics constructs are defined for object level programming treating objects as abstract data types. The OOP defined by the present programming techniques have tree rewrite automatic implementations. The techniques, concepts, and paradigms defined by the Project are as follows. Intelligent Objects, MJOOP - The Multiagent Junction to OOP; Intelligent OOP Languages; String and Splurge Functions; The Object Coobject Design Paradigm; The Pullup Abstraction Function; and Multi Kernel AI Designs With Intelligent Objects 1. Intelligent Objects and Multi Agent OOP The term "agent" has been recently applied to refer to AI constructs that enable computation on behalf of an AI activity[1,2,3]. It also refers to computations that take place in an autonomous and continuous fashion, while considered a high-level activity, in the sense that its definition is software/hardware, thus implementation, independent [1,4]. The present project develops new techniques, and linguistics constructs for programming with objects implemented by agents, based on a theory of computing with trees on signatures carrying agent functions on trees [5]. The agents are designated functions with specified functionality and message syntax. Thus context can be carried at syntax. We present new techniques and languages for object level programming with intelligent trees implemented by agent functions. We show in [6], and brief in the present paper, how a two-level language paradigm and intelligent object level programming can handle what otherwise is a complicated computing phenomena. There are objects as situated automata, for which abstract syntax trees and a computing theory merging with the current practice of programming theories is quite impossible. 2. PROGRAMMING LINGUISTICS And INTELLIGENT SYNTAX This project is towards programming techniques that could provide a foundation for the method of computing that is inevitable with the current and forthcoming AI programming techniques, supported by our theoretical development in [5,6].. There is a gap between the OOP object programming trends and objects as applied to AI programming [13,14,16]. We had started on a project to bridge the abstract data type AI KR in our 1985 paper [15]. For OOP the AI application areas are outlined in [10,11,13]. The present paper offers a syntactic OOP techniques applicable to AI and ordinary OOP. An important technical point is that the agents are represented by function names that appear on the free syntax trees of implementing trees. The trees defined by the present approach have function names corresponding to computing agents. The computing agent functions have a specified module defining their functionality. 2.1 Intelligent Syntax By an intelligent language we intend a language with syntactic constructs that allow function symbols and corresponding objects, such that the function symbols are implemented by computing agents in the sense defined by this author in [5,6]. A set of function symbols in the language, referred to by Agent Function Set, are function symbols that are modeled in the computing world by AI Agents. The objects, message passing actions, and implementing agents are defined by syntactic constructs. Agents appear as functions, expressed by an abstract language that is capable of specifying modules, agents, and their communications. We have put this together with syntactic constructs that could run on the tree computing theories that are presented in [7]. Definition 2.1 We say that a syntax is intelligent iff it has intelligent function symbols. [] Definition 2.2 A language L is said to be an intelligent language iff L is defined from an intelligent syntax. [] The most recent language support for AI programming, languages are pursued where objects are at play without much handle on the syntax trees. Objects appear on various semantic networks and are a sort of situated automata, that implement a computation by asynchronous methods. Our goal in the present project is to have language constructs that allow us to handle objects on abstract syntax trees and implement the mystical behavior of situated automata by agents. 3. String and Splurge Functions Formal techniques with intelligent syntax, String and Splurge programming linguistics allow us to treat visibility in a precise way and to get theoretical results [5,6,7] for MJOOP and OOP. These techniques and our formalization for AI computations [9] lead to an exciting new programming theory and practice for MJOOP. The new programming technique present the basis for programming with nondeterministic syntax[11]. Definition 3.1 We say that a function f is a string function iff there is no message passing or information exchange except onto the object that is at the range set for f, reading parameters visible at each object. Otherwise, f is said to be a splurge function. We refer to them by string and splurge functions when there is no ambiguity. Remark: Nullary functions are string functions. Amongst the functions in AFS only some interact by message passing. By defining String and Splurge functions we can have a formal treatment for programming with objects to handle object visibility and other related OOP computation problems. 4. The Pullup Abstraction Function 4.1 The Two Level Language Paradigm The abstract syntax put forth for to be implemented are expected at two levels. Level 1 is a language that only expresses the functionality of modules by names of objects and their message passing Actions, and abstract data types , for example by SLPX[8]. Level 2 defines the functions themselves. The implementing agents, their corresponding objects and their message passing actions can also be presented by the two-level abstract syntax. From the practical stand point, the models as individual programs can be specified with well known specifications languages. 4.2 The Abstraction Function To handle the compatibility problem, arising often in OOP, we have defined the Pullup abstraction function in [7]. The idea is when defining operations across two incompatible objects, in the sense of types and the set of operations defined for each, we pullup either or both objects to abstract objects for which we could define compatible operations across the resulting abstract objects. The analogy to Pullup at the operation level is overloading, except Pullup is a structural paradigm. A trivial example might be the objects defining a Chair with the operations of sitting on or getting up defined, and the object Table with operations having to do with putting things on, or taking things off the Table. We might Pullup the objects Chair and Table to the object Dinning_Table. 5. The Object Coobject Design Paradigm It would be nice to view the problem form the stand point of an example. The example of intelligent languages we could present have Object:= IOOP_BREW OPS:= Serve_Coffee (Type,Table_no) | ...... Serve_Coffee (Spectacular_Brew,n) => Signal an available robot to fetch and serve (Spectacular_Brew,table n) Exp:= Serve_Coffee (Spectacular_Brew,Table_no) |... Serve_coffee(Spectacular_Brew,Table_no) => if out_of_it notify Table_no; offer today's-brew offer alternatives> In the above example OPS denotes operations, EXP denotes exceptions, and the last equation defines the exception action. In this example there is a process(action) that is always checking the supply of a specific coffee implementing the exception function. As another example, while planning for space exploration, an agent might be assigned by the onboard computer system to compute the next docking time and location, with a known orbiting space craft. The objects and message passing by agents are programmed on SLPX [8] and the actual module definitions, for example the Coffee-Shop is defined by the parameterized algebraic specification language Compose. The object-coobject paradigm has been applied by this author to define new computing paradigms for artificial intelligence with multi agents, called Double Vision Computing[10]. 6. The Multi Kernel OOP Technique This is a design technique with multi kernels, formed from 7. CONCLUDING COMMENTS The author envisions that the method of intelligent syntax and computing with intelligent objects to become a promising method of computing and in some sense inevitable programming paradigms over the next decade. Thus the MJOOP paradigm is to be an exciting practical trend as well as a theoretical development for OOP. The interplay of our computational linguistics techniques [5] with the method of intelligent syntax put forth here and in [5,6,7] could provide us with exciting expressive languages. The techniques are applicable to distributed OOP,e.g. [12]. We have presented a two-level language approach to object level programming and put forth the motivation and a basis for a theoretical development applying intelligent syntax trees to object level programming with multi-agent AI methods. New linguistics constructs are put forth for object level programming with abstract data types. REFERENCES [1] Nourani, C F."Abstract Implementations By Computing Agents:A Conceptual Overview," March 3, 1993 , Proc. SERF-93, Orlanda, FL, November 1993. [2] Genesereth, M.R and N.J. Nilsson, Logical Foundations of Artificial Intelligence, Morgan-Kaufmann, 1987. [3] Nourani, C.F.,"A Multi_Agent Approach To Fault-Free and Fault Tolerant AI," Proc. FLAIRS,93, Sixth Florida AI Research Symposium, April 1993. [4] ___________," Abstract Implementations and Their Correctness Proofs," JACM, April 1993. [5] ___________," Abstract Intelligent Tree Computing And A Tree Rewrite Theory For OOP", January 19, 1995, Abstract Data Types 95, Holmenkollen, Norway. [6] ___________,"Intelligent Object Level Computing," June 1993. [7] ___________,"Slalom Trees Computing," April 1993, AI Communications, November 1996, IOS Press. [8] ___________"Parallel Module Specification on SLPX," November 1990,SIGPLAN, January 1992. [9] ___________,"Planning and Plausible Reasoning in AI,"Proc. Scandinavian AI Conference , May 1991, Denmark, 150-157, IOS Press. [10] Nourani, C.F., "Double Vision Computing," December 1993, IAS-4,Karlsruhe, Germany. [11] _____________"Liberating Programming From Deterministic Syntax," September 1995. [12] Liskov ,B, et.al., The Language-Independent Interface of the Thor Persistent Object System, MIT Programming Methodology Group Memo 80, March 1994. [13] R. Fikes and T. Kehler, ?The Role of frame-based representation in reasoning," CACM 28, No.9, pages 904-920, 1985. [14] R.J.Brachman, R.E.Fikes, and H.J.Levesque, KRYPTON: A Functional Approach to Knowledge Representation," in Readings in Knowledge Representation, Brachman and Levesque editors,Morgan-Kaufmann. [15]Nourani, C.F. and K.J. Lieberherr, "Data Types, Direct Implementations, and Knowledge Representation," Proc. 19th HICSS, Honolulu, Hawaii, January 1986, Vol II, pp. 233-243. [16] R.P. Ten Dyke and J.C. Kunz, "Object Oriented Programming," IBM Systems Journal, vol. 28, no. 3, 1989. | |||||||||||||||||
| Figures at http:\\memebrs.fortunecity.com/Crisfn/Intobjcmp.html and Objcob.html | ||||||||||||||||||
|
| ||||||||||||||||||
| Also See http://memebrs.fortunecity.com/crisfn/ooprcmdl.html | ||||||||||||||||||
|
| ||||||||||||||||||
| ||||||||||||||||||
|
This page has been visited
|
