- Email: [email protected]
Online algorithms supporting emergence in distributed CAD systems
Advances in Engineering Software 32 (2001) 779±787
www.elsevier.com/locate/advengsoft
Online algorithms supporting emergence in distributed CAD systems B. Feijo a,*, P.C.R. Gomes a, S. Scheer b, J. Bento c a
Intelligent CAD Laboratory, Department of Computing, PUC-Rio, R. MarqueÃs de S. Vicente 225, CEP 22453-900 Rio de Janeiro, RJ, Brazil b CESEC/TC/UFPR - Caixa Postal 19011, CEP 81531-990, Curitiba, PR, Brazil c DECivil, Instituto Superior TeÂcnico, Technical University of Lisbon, Av. Rovisco Pais, 1096 Lisboa Codex, Portugal Received 10 November 1999; accepted 2 April 2001
Abstract The rule-based approach from traditional AI and the conventional constraint satisfaction algorithms are not adequate to cope with the unpredictable events and interactive computations in distributed CAD environments. This paper claims that the problems faced by distributed CAD systems require solutions based on the concepts of emergence, reactivity, and online algorithms. The present paper presents Extended Constraints Graphs (ECGs) as online algorithms supporting emergence in a network of reactive agents. ECGs represent an effective solution for the nonlinear constraint problem in cyclic graphs, which are distributed over a heterogeneous computer network. The relationships between agents in an ECG are generic, distributed, recursive and nonlinear Ð a problem not solved in the literature. Also this paper presents a CORBA model integrated with a Geometry Bus to support distributed virtual prototype whose variables can be de®ned in terms of ECGs. q 2001 Civil-Comp Ltd and Elsevier Science Ltd. All rights reserved. Keywords: CAD; Distributed objects; Online algorithms; Emergence
1. Introduction In a distributed CAD system, the virtual prototype is dispersed over the enterprise network in different platforms, operating systems, visualization equipments and design teams. Fig. 1 shows the complexity of such an integrated environment, where highly dynamical processes occur physically supported by a high-speed network. In distributed CAD systems, one should consider geometry buses and object-distributed computing as enabling technologies. The geometry bus makes interoperability possible and allows designers to cooperate among themselves using different CAD programs in the network. ACIS [1] and CORBA [2] have been proposed as a geometry bus and distributed object architecture for integrated CAD systems respectively [3,4]. A change that a designer makes in a 3D object may affect another 3D object that is being manipulated in another part of the network. In a general way, the components of the distributed virtual prototype should keep some sort of relationship amongst them and should react to changes in the environment made by design agents. The problem of reactivity in virtual prototyping is manifold and this paper tackles some of its main aspects. * Corresponding author. Tel.: 155-21-2529-9544 4308, fax: 155-212259-2232. E-mail address: [email protected] (B. FeijoÂ).
Most of the implementation methods in intelligent CAD systems are strongly based on a symbolic representation of the design world. However, the classical symbolic AI paradigm has several drawbacks: (1) the frame problem; (2) computational inef®ciency; (3) incapability of coping with unpredictable events; and (4) inability to cope with interactive computation. This situation is even more complex in the context of distributed Arti®cial Intelligence. In this particular, the authors claim that the intelligent behaviors of the objects in distributed CAD systems are more ef®ciently represented by `emergence' rather than `intelligence'. Emergence means that the `intelligence' of an agent emerges from the interaction of agents among themselves and with their environment. Emergence is one of the cornerstones of reactivity. A reactive agent must respond dynamically and ef®ciently to changes in their environment. The concepts of emergence and reactivity are discussed by Feijo and Bento [5] in the context of intelligent CAD systems. Also the problem of reactivity in a distributed solid modeling environment has already been discussed elsewhere [6,7]. In this paper, the authors expand their previous works with the concept of online algorithms in a distributed environment. The great complexity and the highly dynamical nature of the distributed CAD systems require solutions that go beyond conventional constraint solvers and other traditional algorithmic solutions. Most of the traditional algorithmic problems assume that the algorithm starts with complete
0965-9978/01/$ - see front matter q 2001 Civil-Comp Ltd and Elsevier Science Ltd. All rights reserved. PII: S 0965-997 8(01)00029-1
780
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
Fig. 1. Distributed Virtual Prototype.
knowledge of the entire input and no changes are allowed during its execution. Any change should wait for the algorithm to be ended or aborted. This sort of algorithm is called of¯ine in order to contrast with the concept of online algorithms [8,9]. In most of the complex problems, the input is only partially available, because some relevant input data will arrive in the future. An online algorithm must generate an output without the knowledge of the entire input. This is exactly the situation to be considered in the scenario of Fig. 1. In this paper an agent means an object with its own goals or an interface object representing the user's intention. The agents distributed over the network of the Fig. 1 can be represented by graphs that establish commitments (i.e. relationships between agent's attributes) and allow negotiation or modi®cation of attributes while an online algorithm is running. Fig. 2 illustrates agents participating of commitments and negotiations while an online algorithm is trying to satisfy a set of constraints involving the variables h, r and s (e.g. h 3r 1 s=2 and s 2r: At any time, an agent may change the value of an attribute or alter a commitment (e.g. changing an equation or eliminating a relationship entirely), without stopping the algorithm. The challenges to building such a highly reactive environment are enormous. Firstly, an online algorithm for nonlinear constraint problems in cyclic graphs should be developed. Secondly, the online algorithm should run over a heterogeneous computer network. Thirdly, the 3D modeling and visualization tasks should be done from a set of CAD systems working cooperatively and simultaneously over the network. This paper searches for effective solutions for these questions.
The present work starts proposing a new pragmatic view of emergence, which supports the proposals made in this paper. Afterwards, this paper presents the Extended Constraint Graphs as a way of sustaining online algorithms for nonlinear constraint problems over distributed computer systems. Extended constraint graphs require a recursive solution in order to reach an equilibrium state. In this particular aspect, the authors present a new solution for the problem of recursion in distributed cyclic graphs. Finally, this paper proposes a model to integrate CORBA and ACIS, which is an essential module to make possible the implementation of the system over a heterogeneous network. Extended constraint graphs, working as online algorithms, support a form of emergence and are a promising framework to work with a society of distributed reactive objects
Fig. 2. Interacting objects.
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
Ð a topic of great interest for the next generation of CAD systems. 2. Emergence Emergence, where simple systems generate complex ones, is a fundamental concept in many modern scienti®c theories. A diversity of phenomena such as chess playing, neural processing, and even the origin of life are emergent phenomena. Some popular de®nitions of emergence are too ubiquitous to be taken seriously in computer applications, for instance: ² emergence is the notion that the whole is more than the sum of its parts; ² emergence means the existence of properties of a system that are not possessed by any of its parts; ² emergence is the notion that a small number of rules of laws can generate systems of surprising complexity. J.H. Holland [10] presents a good introduction to the broad concept of emergence in science. Although emergence is not a totally new idea, only after the seminal works by Minsky [11] and Brooks [12±15] this concept started being strongly examined by computer scientists. Forrest [16] suggests the term `emergent computation', in substitution of the terminology `nonlinear properties of computational systems' broadly used in the beginning of the '90s. In this paper, emergence means that the `intelligence' of an agent emerges from the interaction of the agents among themselves and with their environment without the need of representing the agents' mental states. Minsky [11] does not use the term `emergence', but presents this concept in terms of a society of mindless agents. Brooks [14] makes the following intriguing statement: ªIt is hard to identify the seat of intelligence within any system, as intelligence is produced by the interactions of many components. Intelligence can only be determined by the total behavior of the system and how that behavior appears in relation to the environment. The key idea of emergence is: Intelligence is in the eye of the observer. Following the line of reasoning by Brooks [14], the concept of emergence also requires the concept of situatedness that states that the intelligence of an agent is situated in the world and not in any formal model of the world built in the agent. According to this latter concept, an agent uses its perception of the world rather than deductions based upon a symbolic representation of this world. The authors suggest that the concept of emergence proposed by Brooks should be increased with the following restrictive assumptions: 1. emergence can only exist in designed systems; 2. emergence requires that not only the agents but also their ways of interaction be simple;
781
3. emergence requires interactive computation rather than algorithmic computation. The ®rst two assumptions above are closely aligned with the following two interpretations of emergence by D.J. Chalmers [17]: ² emergence is the phenomenon wherein a system is designed according to certain principles, but interesting properties arise that are not included in the goals of the designer; ² emergence is the phenomenon wherein complex, interesting high-level function is produced as a result of combining simple low-level mechanisms in simple ways. The importance of the assumptions (1) and (2) above is that the concept of emergence becomes narrower than the ubiquitous de®nitions mentioned in the beginning of this section. Ubiquitous de®nitions are useless to build models based on information-processing systems. For instance, under the popular de®nitions of emergence, any computation performed by a C11 program is an emergent phenomenon relative to the low-level circuit operations. The notion of emergence must be more restrictive than that. According to assumption (1), emergence is more adequate to be considered in the sciences of the arti®cial [18], that is, where objects and phenomena are produced by designers or artists. The assumption (2) rules out any computer program whose objects have complex ways of combination or interaction. Some examples of working systems can be found in the literature of computer science where one can identify the presence of these assumptions. For instance, the behavioral animation system by C. Reynolds [19] illustrates how unpredictable choreographs of ¯ocks of birds emerge from simple objects obeying a small number of simple rules like `follow the leader', `keep close to others', and `avoid obstacle'. The assumption (3), which also narrows the concept of emergence, means that complexity belongs to the external world. In this case, the focus should be shifted from the close-world assumption of a set of algorithmic rules to the open-world of interactive systems. Here, the appropriate metaphor is that illustrated by H.A. Simon [18] with the example of the irregular behavior of an ant making his laborious way across a wind- and a wave-molded beach. In this example, the computing mechanism of the ant is supposed to be simple, but the ant's behavior re¯ects the complexity of the ground over which the ant walks. This sort of argument have recently been discussed by computer scientists suggesting that interaction is more powerful than algorithms [20]. Emergence is an important issue in CAD systems because it supports event-driven design processes [7], where designs are driven by events in a highly dynamical and interactive environment rather than formal explicit rules in a closedworld domain. It is a usual mistake to understand emergence as a form
782
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
of connectionism. Firstly, connectionism seems not to represent a radical detour in computational intelligence. Secondly, traditional connectionist networks are driven by algorithmic computation rather than interactive. Several works have stated that the allures of connectionism are illusory, and it is best used as a very ef®cient implementation strategy [21]. Using terms from cognitive science, emergence belongs to the stream of eliminativism, where there is no vocabulary that characterizes mental states in terms of what they represent. On the other hand, connectionism is a model of representationalism, where there are states of mental representation that encode the states of the world [21]. Both connectionism and classicism (where cognition is based on operation with symbols) are models of representationalism. The ®rst assigns semantic content to nodes, while the later assigns it to symbolic expressions. From the point of view of computation, connectionist models use of¯ine algorithms while emergence is naturally based on online algorithms. It is reasonable to accept the idea that there is no sharp boundary between what has emergent behavior and what has not. The authors propose that the above-mentioned assumptions (1) to (3) be used to de®ne variations from a central case of emergence. The central case represents the situation of strong emergence, where all assumptions (1) to (3) are present. In this context, connectionist networks have a certain degree of emergence, as some software agents in the internet. 3. Extended Constraint Graphs An extended constraint graph (ECG) is denoted as: G V; M; E where V and M are sets of vertices representing variables and methods, respectively, and E is a set of partially directed edges denoting the link between V and M. Fig. 3 illustrates an extended constraint graph. In an ECG, variables have the form agt[.attribute] and methods are de®ned by the following elements:
1. A condition (usually a constraint equation), e.g. h 3r 1 b=2 or a fuzzy relationship `X is slightly higher than Y '; 2. The inverse of this condition, e.g. r 1=3 h 2 b=2 or `Y is slightly lower than X'; 3. A piece of code for each direction of the link, e.g. in the direction r ! h of Fig. 3: `if condition r 1=3 h 2 b=2 is not satis®ed, then run the function AddValue to de®ne a new h such that h 3r 1 b=2'. When a method links more than two variables, it forms a hyper-edge. An agent can negotiate the establishment of a condition and create a link in the extended constraint graph. The generality of this approach leads to an online algorithm that embraces nonlinear constraint solving, which has no reference in the literature. Every variable AGTiTj has a list link_to with pairs containing a variable and a function, that is: ¼ ¼l; ¼ Link-to kAGTk Tn ; reactionkn ij l; k ; The recursive nature of the constraint satisfaction problem is made clear by the algorithm proposed in Fig. 4. Each visited node may generate n sub-trees of recursive calls of the function AddValue. 4. A solution for the distributed recursion This paper proposes a control mechanism for parallel processing based on the architecture MIMD Ð Multiple Instruction Stream, Multiple Data Stream, where each processing entity has its own control [22]. The proposed mechanism creates a distributed register stack of the recursive calls. The sequence of the visited nodes corresponds to the sequence of the recursive calls of the function AddValue. In a speci®c processing unit, each time a new instance of AddValue is started, the stack stores a reference to the remote agent that ®red this instance. When all the links of the agent living in that speci®c processing unit return TRUE,
Fig. 3. An extended constraint graph (ECG).
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
783
Fig. 4. Algorithm for reactivity in an ECG.
this agent sends a message to its father agent in the recursion tree informing its current state as being TRUE. This process goes up in the recursion tree similarly until the processing reaches the node `root'. The algorithm is over when all the links of the node `root' have the state TRUE. A new element called status is incorporated in the list link-to to store the current state of a variable. The function AddValue of Fig. 4 is extended with the new parameter parent_ref and several lines of the recursion control, as shown in Fig. 5. The variable ig is a global one. The function VerifyLinksTrue veri®es if status is TRUE, manipulates the stack, and checks if the whole process ends (i.e. if status TRUE and stack.Top( ) `root'). The function reactionijkn should also have an extra line updating the list link-to as follows: AGTi:link-to ig à TRUE
5. An online algorithm for the ECG An agent (or a user) may change the value of an attribute while the algorithm described in the previous section is running. The situation may be even more complex if the
Fig. 5. Recursion control in AddValue.
function reactionijkn includes a line of code creating a new agent and establishing new relationships at run time. The algorithm should not be interrupted in any circumstance; that is, it should keep running without the knowledge of the entire input. This is typically an online algorithm. The ECGs are intrinsically online algorithms and only require a heuristics to establish preference amongst concurrent processes. In this paper, the following very simple heuristics is used: `the most recent process has the highest priority'. The consequences of one or more changes in an ECG may be isolated or overlapped depending on the extension of the reactions, as shown in Figs. 6 and 7. In Fig. 6, a process P1 is ®red in node 1 (e.g. cube2t 5) and the algorithm ®nds a solution visiting nodes one to four (marked with p). The border f1 delimits the region of reaction. When another process P2 is ®red (e.g. cyl1.r 10), a solution (marked with 1) is found without overlapping border f1 and the processes are isolated. In Fig. 7, P2 causes reactions in such a way that the border f2 overlaps the border f1. In this case, the process P1 is discarded and the border f2 may continue its expansion until node 1 is reached. In this paper, the strategy for implementing the online algorithm uses multithread programming and an idea inspired in the technique of time stamping for distributed algorithms [23]. In the algorithm described in Section 5, the calls to remote functions should pass the process identi®cation number. In a server agent, if the process identi®cation number of the client agent is older than the current process, the remote call will be ignored and the server will return a message communicating this fact to the client. If this is not the case, the server will update the identi®cation number of the current process and terminate the local process. This means that the recursion stack of the older process will be discarded.
784
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
Fig. 6. Isolated processes in an ECG.
6. The CORBA model The distributed online algorithm developed above requires a middleware, in order to be implemented over a heterogeneous network. However, this is not a simple matter of choosing a product from the shelves. Firstly, the geometry bus should be integrated with the middleware for distributed objects over heterogeneous systems. Secondly, an appropriate language should be developed to deal with the dynamic invocation interfaces at run time. Previous works by the authors propose the integration of CORBA with the geometry bus ACIS [6]. There is a great scarcity of references on ACIS±CORBA integration. Furthermore, the majority of CORBA applications in CAD systems use static invocations. In this particular, there are virtually no references on dynamic distributed objects in CAD systems. In the present paper, the authors support the use of the interpreted language Lua [24] with a CORBA binding called
LuaOrb [25] to integrate ACIS with the CORBA dynamic invocation interface. Details of this approach can be found elsewhere [6]. Fig. 8 shows the proposed CORBA model in which an application module is simultaneously client and object implementation. In this model, The Abstract Data Object (ADO) is a C11 class containing the object's geometry data (ACIS). The class wrapper is the ORB skeleton (i.e. the server) with methods that can be called via CORBA. These methods access the ADO and also communicate with the Lua code to update the user interface. Proxy is a LuaOrb object through which Lua accesses the methods of a remote object via CORBA. This CORBA model can gracefully support the example of Fig. 3, where four designers are using four different computers simultaneously. In this example, if a designer changes the value of an attribute the complete artifact will be adjusted and exhibited three-dimensionally in all four
Fig. 7. Overlapped processes in an ECG
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
785
Fig. 8. The CORBA model.
machines without stopping the tasks the designers are currently performing. 7. Closure The rule-based approach from traditional AI and the conventional constraint satisfaction algorithms are not adequate to cope with the unpredictable events and interactive computation in distributed CAD environments. In this paper, the authors explore new possibilities for distributed CAD systems based on the concepts of emergence, reactivity, and online algorithms. Furthermore, a more pragmatic view of emergence is proposed. The constraint relationships between agents in the ECGs can be nonlinear and the graph can be cyclic. The problem of constraint satisfaction in cyclic graphics is not trivial and the search for ef®cient algorithms is still an open issue [26,27]. The present paper presents a solution for the nonlinear constraint problem in cyclic graphs, which are distributed over a heterogeneous network. The relationships between agents in an ECG are generic, distributed, recursive
and nonlinear. The authors are not aware of any other online algorithm with these characteristics in the literature. This paper presents an effective solution for the problem of distributed recursion. References to distributed recursion are scarce. Florin et al. [28] de®ned an interesting framework for writing recursive distributed algorithms called `distributed recursive waves'. However, their solution does not support online algorithms. Although powerful, ECGs are not ef®cient. However, the performance analysis of online algorithms, a new and dif®cult area of research, is not in the scope of the present paper. Albers [8] suggests evaluating the performance of an online algorithm using competitive analysis. In a competitive analysis an online algorithm A is compared to an optimal of¯ine algorithm, which is a reference of minimum cost. In this technique, given a request sequence s, the online algorithm A is called c-competitive if and only if there is a constant a such that: CA s # c:COPT s 1 a Where CA(s) is the cost of A, COPT(s) is the cost of the
Fig. 9. An ECG containing a variable with 2 hyper-edges.
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
786
Table 1 Tolerance vs. recursion level for the ECG of Fig. 9 Tolerance
Maximum level of recursion
0.3 0.1 0.05 0.001 0.0005 0.00001 0.000005
11 15 16 28 53 53 53
optimal of¯ine algorithm, c is called the competitive rate of A, and s is the sequence s(1), s(2),¼ Some trivial experiments show that the algorithm proposed in this paper is strongly in¯uenced by numerical tolerance. Fig. 9 presents an ECG containing a variable with two hyper-edges, which was tested with several tolerances. The results of the numerical tolerance tests are presented in Table 1. The ECGs can easily be used to introduce intervals for speci®c variables. Fig. 10 illustrates the case where the height of a box should be in the interval (a, b). The purpose of an ECG is not the search for an optimal solution, as it is the case of traditional constraint satisfaction algorithms. The objective of an ECG is to provide a qualitative and sensitivity analysis of the behavior of a society of reactive agents. From the viewpoint of interactive computation, there is here a contrast with traditional mathematical programming, similar to the opposition of emergence to conventional `arti®cial intelligence'. In both cases one can recognize an opposition against pure of¯ine algorithmic computation, which cannot cope with the surprises, creative moments and ongoing history of the design processes. This paper presents a complete work, from concepts up to algorithms and distributed computing solutions. However, the subject is vast and further work is required. The main line for future work is to investigate the performance of the
Fig. 10. Variable h within (a,b).
ECGs in real applications in design. Also future work should be done to develop a model of negotiation between agents for the establishment of the initial sets of constraints. Acknowledgements The authors would like to thank CNPq, Brazil, and FCT, Portugal, for their ®nancial support. Thanks are also due to Renato Cerqueira for his support in LuaOrb. References [1] Spatial Technology, ACIS 3D Toolkit Version 5.0 (manuals). Spatial Technology Inc., Boulder, CO, 1999. [2] Siegel J. CORBA Fundamentals and Programming. New York: Wiley, 1996. [3] Porter S. What's up with ACIS? Comput Graph World 1995;18(9):30±6. [4] Regli WC. Intranet-enabled Computer-Aided Design. IEEE Internet Comput 1997;1(1):39±50. Also in http://www.computer.org/ internet/ backissu.htm [5] Feijo B, Bento J. A logic-based environment for reactive agents in intelligent CAD systems. Adv Engng Software 1998;29(10):825±32. [6] Gomes PCR, Feijo B, Cerqueira R, Ierusalimschy R. In: Horvath I, Taleb-Bendiab A, editors. Reactivity and pro-activeness in virtual prototyping, 2nd Int Symposium on Tools and Methods for Concurrent Engineering,TMCE'98, 21±23 April. Manchester, UK: Manchester Metropolitan University, 1998. p. 242±53. [7] Feijo B, Gomes PCR, Bento J, Scheer S, Cerqueira R. Distributed agents supporting event-driven design processes. Gero JS, Sudweeks F, editors. Arti®cial Intelligence in Design '98 1998:557±77. [8] Albers S. Competitive online algorithms. Optima Ð Mathl Program Soc Newsl 1997;54(June):1±8. [9] Irani S, Karlin AR, On online computation, http://www.ics.uci.edu/ ~irani/Online/Online.html [10] Holland JH. Emergence: from chaos to order. Cambridge, MA: Perseus Books, 1999. [11] Minsky ML. The society of mind. London: Pan Books, 1988. [12] Brooks RA. A robust layered control system for a mobile robot, Technical Report A.I. Memo 864. Cambridge, MA: Arti®cial Intelligence Laboratory, MIT, 1985. [13] Brooks RA. Elephants don't play chess. In: Maes P, editor. Designing autonomous agents: theory and practice from biology to engineering and back. Cambridge, MA: MIT Press, 1990. p. 3±15. [14] Brooks RA. Intelligence without reason, A.I. memo 1293. Cambridge, MA: Arti®cial Intelligence Laboratory, MIT, 1991. [15] Brooks RA. Intelligence without representation. Artif Intell 1991;47:139±59. [16] Forrest S. Emergent computation. In Proceedings of the Ninth Annual International Conference of the Center for Nonlinear Studies on Selforganizing, Collective, and Cooperative Phenomena in Natural and Arti®cial Computing Networks, Los Alamos, NM, May 22±26. North Holland, 1989. [17] Chalmers DJ. Thoughts on emergence, Newsgroup communication, comp.ai.philosophy, 6 Oct 90, in siteling.ucsc.edu/~chalmers/notes/ emergence.html, last access in 4 Jun 1999. [18] Simon HA. The sciences of the arti®cial. 2nd ed. Cambridge, MA: MIT Press, 1981. [19] Reynolds C. Flocks, herds and schools: a distributed behavioral model. Comput Graph 1987;21:25±34. [20] Wagner P. Why interaction is more powerful than algorithms. Commun ACM 1997;40(5).
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787 [21] Fodor JA, Pylyshyn ZW. Connectionism and cognitive architecture: a critical analysis. Cognition 1988;28:3±71. [22] Kumar V, Grama A, Gupta A, Karpis G. Introduction to parallel computing: design and analysis of parallel algorithms. Benjamin/ Cummings, 1994. [23] Raynal M. Distributed algorithms and protocols. New York: Wiley, 1992. [24] Ierusalimschy R, Figueiredo LH, Celes WF. Lua Ð an extensible extension language. Software: Pract Exper 1996;26(6):635±53. Also see http://www.tecgraf.puc-rio.br/lua/. [25] Cerqueira R, Rodrigues N, Ierusalimschy R. Binding in interpreted language to CORBA, SimpoÂsio Brasileiro de Linguagens de ProgramacËaÄo 1997 p 23±36.
787
[26] Zanden BV. An incremental algorithm for satisfying hierarchies of multiway data¯ow constraints. ACM Trans Program Lang Syst 1996;18(1):30±72. [27] Tsai YT, Fernando T, Dew PM. Exploiting degrees of freedom analysis for interactive constraint-based design, Technical report 95.36. UK: School of Computer Studies, University of Leeds, 1995. [28] Florin G, Gomez R, Lavalle I. Recursive distributed programming schemes, Proceedings ISADS'93: International Symposium on Autonomous Decentralized Systems. Kawasaki, Japan: IEEE Computer Society, 1993, pp 122±8.
www.elsevier.com/locate/advengsoft
Online algorithms supporting emergence in distributed CAD systems B. Feijo a,*, P.C.R. Gomes a, S. Scheer b, J. Bento c a
Intelligent CAD Laboratory, Department of Computing, PUC-Rio, R. MarqueÃs de S. Vicente 225, CEP 22453-900 Rio de Janeiro, RJ, Brazil b CESEC/TC/UFPR - Caixa Postal 19011, CEP 81531-990, Curitiba, PR, Brazil c DECivil, Instituto Superior TeÂcnico, Technical University of Lisbon, Av. Rovisco Pais, 1096 Lisboa Codex, Portugal Received 10 November 1999; accepted 2 April 2001
Abstract The rule-based approach from traditional AI and the conventional constraint satisfaction algorithms are not adequate to cope with the unpredictable events and interactive computations in distributed CAD environments. This paper claims that the problems faced by distributed CAD systems require solutions based on the concepts of emergence, reactivity, and online algorithms. The present paper presents Extended Constraints Graphs (ECGs) as online algorithms supporting emergence in a network of reactive agents. ECGs represent an effective solution for the nonlinear constraint problem in cyclic graphs, which are distributed over a heterogeneous computer network. The relationships between agents in an ECG are generic, distributed, recursive and nonlinear Ð a problem not solved in the literature. Also this paper presents a CORBA model integrated with a Geometry Bus to support distributed virtual prototype whose variables can be de®ned in terms of ECGs. q 2001 Civil-Comp Ltd and Elsevier Science Ltd. All rights reserved. Keywords: CAD; Distributed objects; Online algorithms; Emergence
1. Introduction In a distributed CAD system, the virtual prototype is dispersed over the enterprise network in different platforms, operating systems, visualization equipments and design teams. Fig. 1 shows the complexity of such an integrated environment, where highly dynamical processes occur physically supported by a high-speed network. In distributed CAD systems, one should consider geometry buses and object-distributed computing as enabling technologies. The geometry bus makes interoperability possible and allows designers to cooperate among themselves using different CAD programs in the network. ACIS [1] and CORBA [2] have been proposed as a geometry bus and distributed object architecture for integrated CAD systems respectively [3,4]. A change that a designer makes in a 3D object may affect another 3D object that is being manipulated in another part of the network. In a general way, the components of the distributed virtual prototype should keep some sort of relationship amongst them and should react to changes in the environment made by design agents. The problem of reactivity in virtual prototyping is manifold and this paper tackles some of its main aspects. * Corresponding author. Tel.: 155-21-2529-9544 4308, fax: 155-212259-2232. E-mail address: [email protected] (B. FeijoÂ).
Most of the implementation methods in intelligent CAD systems are strongly based on a symbolic representation of the design world. However, the classical symbolic AI paradigm has several drawbacks: (1) the frame problem; (2) computational inef®ciency; (3) incapability of coping with unpredictable events; and (4) inability to cope with interactive computation. This situation is even more complex in the context of distributed Arti®cial Intelligence. In this particular, the authors claim that the intelligent behaviors of the objects in distributed CAD systems are more ef®ciently represented by `emergence' rather than `intelligence'. Emergence means that the `intelligence' of an agent emerges from the interaction of agents among themselves and with their environment. Emergence is one of the cornerstones of reactivity. A reactive agent must respond dynamically and ef®ciently to changes in their environment. The concepts of emergence and reactivity are discussed by Feijo and Bento [5] in the context of intelligent CAD systems. Also the problem of reactivity in a distributed solid modeling environment has already been discussed elsewhere [6,7]. In this paper, the authors expand their previous works with the concept of online algorithms in a distributed environment. The great complexity and the highly dynamical nature of the distributed CAD systems require solutions that go beyond conventional constraint solvers and other traditional algorithmic solutions. Most of the traditional algorithmic problems assume that the algorithm starts with complete
0965-9978/01/$ - see front matter q 2001 Civil-Comp Ltd and Elsevier Science Ltd. All rights reserved. PII: S 0965-997 8(01)00029-1
780
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
Fig. 1. Distributed Virtual Prototype.
knowledge of the entire input and no changes are allowed during its execution. Any change should wait for the algorithm to be ended or aborted. This sort of algorithm is called of¯ine in order to contrast with the concept of online algorithms [8,9]. In most of the complex problems, the input is only partially available, because some relevant input data will arrive in the future. An online algorithm must generate an output without the knowledge of the entire input. This is exactly the situation to be considered in the scenario of Fig. 1. In this paper an agent means an object with its own goals or an interface object representing the user's intention. The agents distributed over the network of the Fig. 1 can be represented by graphs that establish commitments (i.e. relationships between agent's attributes) and allow negotiation or modi®cation of attributes while an online algorithm is running. Fig. 2 illustrates agents participating of commitments and negotiations while an online algorithm is trying to satisfy a set of constraints involving the variables h, r and s (e.g. h 3r 1 s=2 and s 2r: At any time, an agent may change the value of an attribute or alter a commitment (e.g. changing an equation or eliminating a relationship entirely), without stopping the algorithm. The challenges to building such a highly reactive environment are enormous. Firstly, an online algorithm for nonlinear constraint problems in cyclic graphs should be developed. Secondly, the online algorithm should run over a heterogeneous computer network. Thirdly, the 3D modeling and visualization tasks should be done from a set of CAD systems working cooperatively and simultaneously over the network. This paper searches for effective solutions for these questions.
The present work starts proposing a new pragmatic view of emergence, which supports the proposals made in this paper. Afterwards, this paper presents the Extended Constraint Graphs as a way of sustaining online algorithms for nonlinear constraint problems over distributed computer systems. Extended constraint graphs require a recursive solution in order to reach an equilibrium state. In this particular aspect, the authors present a new solution for the problem of recursion in distributed cyclic graphs. Finally, this paper proposes a model to integrate CORBA and ACIS, which is an essential module to make possible the implementation of the system over a heterogeneous network. Extended constraint graphs, working as online algorithms, support a form of emergence and are a promising framework to work with a society of distributed reactive objects
Fig. 2. Interacting objects.
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
Ð a topic of great interest for the next generation of CAD systems. 2. Emergence Emergence, where simple systems generate complex ones, is a fundamental concept in many modern scienti®c theories. A diversity of phenomena such as chess playing, neural processing, and even the origin of life are emergent phenomena. Some popular de®nitions of emergence are too ubiquitous to be taken seriously in computer applications, for instance: ² emergence is the notion that the whole is more than the sum of its parts; ² emergence means the existence of properties of a system that are not possessed by any of its parts; ² emergence is the notion that a small number of rules of laws can generate systems of surprising complexity. J.H. Holland [10] presents a good introduction to the broad concept of emergence in science. Although emergence is not a totally new idea, only after the seminal works by Minsky [11] and Brooks [12±15] this concept started being strongly examined by computer scientists. Forrest [16] suggests the term `emergent computation', in substitution of the terminology `nonlinear properties of computational systems' broadly used in the beginning of the '90s. In this paper, emergence means that the `intelligence' of an agent emerges from the interaction of the agents among themselves and with their environment without the need of representing the agents' mental states. Minsky [11] does not use the term `emergence', but presents this concept in terms of a society of mindless agents. Brooks [14] makes the following intriguing statement: ªIt is hard to identify the seat of intelligence within any system, as intelligence is produced by the interactions of many components. Intelligence can only be determined by the total behavior of the system and how that behavior appears in relation to the environment. The key idea of emergence is: Intelligence is in the eye of the observer. Following the line of reasoning by Brooks [14], the concept of emergence also requires the concept of situatedness that states that the intelligence of an agent is situated in the world and not in any formal model of the world built in the agent. According to this latter concept, an agent uses its perception of the world rather than deductions based upon a symbolic representation of this world. The authors suggest that the concept of emergence proposed by Brooks should be increased with the following restrictive assumptions: 1. emergence can only exist in designed systems; 2. emergence requires that not only the agents but also their ways of interaction be simple;
781
3. emergence requires interactive computation rather than algorithmic computation. The ®rst two assumptions above are closely aligned with the following two interpretations of emergence by D.J. Chalmers [17]: ² emergence is the phenomenon wherein a system is designed according to certain principles, but interesting properties arise that are not included in the goals of the designer; ² emergence is the phenomenon wherein complex, interesting high-level function is produced as a result of combining simple low-level mechanisms in simple ways. The importance of the assumptions (1) and (2) above is that the concept of emergence becomes narrower than the ubiquitous de®nitions mentioned in the beginning of this section. Ubiquitous de®nitions are useless to build models based on information-processing systems. For instance, under the popular de®nitions of emergence, any computation performed by a C11 program is an emergent phenomenon relative to the low-level circuit operations. The notion of emergence must be more restrictive than that. According to assumption (1), emergence is more adequate to be considered in the sciences of the arti®cial [18], that is, where objects and phenomena are produced by designers or artists. The assumption (2) rules out any computer program whose objects have complex ways of combination or interaction. Some examples of working systems can be found in the literature of computer science where one can identify the presence of these assumptions. For instance, the behavioral animation system by C. Reynolds [19] illustrates how unpredictable choreographs of ¯ocks of birds emerge from simple objects obeying a small number of simple rules like `follow the leader', `keep close to others', and `avoid obstacle'. The assumption (3), which also narrows the concept of emergence, means that complexity belongs to the external world. In this case, the focus should be shifted from the close-world assumption of a set of algorithmic rules to the open-world of interactive systems. Here, the appropriate metaphor is that illustrated by H.A. Simon [18] with the example of the irregular behavior of an ant making his laborious way across a wind- and a wave-molded beach. In this example, the computing mechanism of the ant is supposed to be simple, but the ant's behavior re¯ects the complexity of the ground over which the ant walks. This sort of argument have recently been discussed by computer scientists suggesting that interaction is more powerful than algorithms [20]. Emergence is an important issue in CAD systems because it supports event-driven design processes [7], where designs are driven by events in a highly dynamical and interactive environment rather than formal explicit rules in a closedworld domain. It is a usual mistake to understand emergence as a form
782
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
of connectionism. Firstly, connectionism seems not to represent a radical detour in computational intelligence. Secondly, traditional connectionist networks are driven by algorithmic computation rather than interactive. Several works have stated that the allures of connectionism are illusory, and it is best used as a very ef®cient implementation strategy [21]. Using terms from cognitive science, emergence belongs to the stream of eliminativism, where there is no vocabulary that characterizes mental states in terms of what they represent. On the other hand, connectionism is a model of representationalism, where there are states of mental representation that encode the states of the world [21]. Both connectionism and classicism (where cognition is based on operation with symbols) are models of representationalism. The ®rst assigns semantic content to nodes, while the later assigns it to symbolic expressions. From the point of view of computation, connectionist models use of¯ine algorithms while emergence is naturally based on online algorithms. It is reasonable to accept the idea that there is no sharp boundary between what has emergent behavior and what has not. The authors propose that the above-mentioned assumptions (1) to (3) be used to de®ne variations from a central case of emergence. The central case represents the situation of strong emergence, where all assumptions (1) to (3) are present. In this context, connectionist networks have a certain degree of emergence, as some software agents in the internet. 3. Extended Constraint Graphs An extended constraint graph (ECG) is denoted as: G V; M; E where V and M are sets of vertices representing variables and methods, respectively, and E is a set of partially directed edges denoting the link between V and M. Fig. 3 illustrates an extended constraint graph. In an ECG, variables have the form agt[.attribute] and methods are de®ned by the following elements:
1. A condition (usually a constraint equation), e.g. h 3r 1 b=2 or a fuzzy relationship `X is slightly higher than Y '; 2. The inverse of this condition, e.g. r 1=3 h 2 b=2 or `Y is slightly lower than X'; 3. A piece of code for each direction of the link, e.g. in the direction r ! h of Fig. 3: `if condition r 1=3 h 2 b=2 is not satis®ed, then run the function AddValue to de®ne a new h such that h 3r 1 b=2'. When a method links more than two variables, it forms a hyper-edge. An agent can negotiate the establishment of a condition and create a link in the extended constraint graph. The generality of this approach leads to an online algorithm that embraces nonlinear constraint solving, which has no reference in the literature. Every variable AGTiTj has a list link_to with pairs containing a variable and a function, that is: ¼ ¼l; ¼ Link-to kAGTk Tn ; reactionkn ij l; k ; The recursive nature of the constraint satisfaction problem is made clear by the algorithm proposed in Fig. 4. Each visited node may generate n sub-trees of recursive calls of the function AddValue. 4. A solution for the distributed recursion This paper proposes a control mechanism for parallel processing based on the architecture MIMD Ð Multiple Instruction Stream, Multiple Data Stream, where each processing entity has its own control [22]. The proposed mechanism creates a distributed register stack of the recursive calls. The sequence of the visited nodes corresponds to the sequence of the recursive calls of the function AddValue. In a speci®c processing unit, each time a new instance of AddValue is started, the stack stores a reference to the remote agent that ®red this instance. When all the links of the agent living in that speci®c processing unit return TRUE,
Fig. 3. An extended constraint graph (ECG).
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
783
Fig. 4. Algorithm for reactivity in an ECG.
this agent sends a message to its father agent in the recursion tree informing its current state as being TRUE. This process goes up in the recursion tree similarly until the processing reaches the node `root'. The algorithm is over when all the links of the node `root' have the state TRUE. A new element called status is incorporated in the list link-to to store the current state of a variable. The function AddValue of Fig. 4 is extended with the new parameter parent_ref and several lines of the recursion control, as shown in Fig. 5. The variable ig is a global one. The function VerifyLinksTrue veri®es if status is TRUE, manipulates the stack, and checks if the whole process ends (i.e. if status TRUE and stack.Top( ) `root'). The function reactionijkn should also have an extra line updating the list link-to as follows: AGTi:link-to ig à TRUE
5. An online algorithm for the ECG An agent (or a user) may change the value of an attribute while the algorithm described in the previous section is running. The situation may be even more complex if the
Fig. 5. Recursion control in AddValue.
function reactionijkn includes a line of code creating a new agent and establishing new relationships at run time. The algorithm should not be interrupted in any circumstance; that is, it should keep running without the knowledge of the entire input. This is typically an online algorithm. The ECGs are intrinsically online algorithms and only require a heuristics to establish preference amongst concurrent processes. In this paper, the following very simple heuristics is used: `the most recent process has the highest priority'. The consequences of one or more changes in an ECG may be isolated or overlapped depending on the extension of the reactions, as shown in Figs. 6 and 7. In Fig. 6, a process P1 is ®red in node 1 (e.g. cube2t 5) and the algorithm ®nds a solution visiting nodes one to four (marked with p). The border f1 delimits the region of reaction. When another process P2 is ®red (e.g. cyl1.r 10), a solution (marked with 1) is found without overlapping border f1 and the processes are isolated. In Fig. 7, P2 causes reactions in such a way that the border f2 overlaps the border f1. In this case, the process P1 is discarded and the border f2 may continue its expansion until node 1 is reached. In this paper, the strategy for implementing the online algorithm uses multithread programming and an idea inspired in the technique of time stamping for distributed algorithms [23]. In the algorithm described in Section 5, the calls to remote functions should pass the process identi®cation number. In a server agent, if the process identi®cation number of the client agent is older than the current process, the remote call will be ignored and the server will return a message communicating this fact to the client. If this is not the case, the server will update the identi®cation number of the current process and terminate the local process. This means that the recursion stack of the older process will be discarded.
784
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
Fig. 6. Isolated processes in an ECG.
6. The CORBA model The distributed online algorithm developed above requires a middleware, in order to be implemented over a heterogeneous network. However, this is not a simple matter of choosing a product from the shelves. Firstly, the geometry bus should be integrated with the middleware for distributed objects over heterogeneous systems. Secondly, an appropriate language should be developed to deal with the dynamic invocation interfaces at run time. Previous works by the authors propose the integration of CORBA with the geometry bus ACIS [6]. There is a great scarcity of references on ACIS±CORBA integration. Furthermore, the majority of CORBA applications in CAD systems use static invocations. In this particular, there are virtually no references on dynamic distributed objects in CAD systems. In the present paper, the authors support the use of the interpreted language Lua [24] with a CORBA binding called
LuaOrb [25] to integrate ACIS with the CORBA dynamic invocation interface. Details of this approach can be found elsewhere [6]. Fig. 8 shows the proposed CORBA model in which an application module is simultaneously client and object implementation. In this model, The Abstract Data Object (ADO) is a C11 class containing the object's geometry data (ACIS). The class wrapper is the ORB skeleton (i.e. the server) with methods that can be called via CORBA. These methods access the ADO and also communicate with the Lua code to update the user interface. Proxy is a LuaOrb object through which Lua accesses the methods of a remote object via CORBA. This CORBA model can gracefully support the example of Fig. 3, where four designers are using four different computers simultaneously. In this example, if a designer changes the value of an attribute the complete artifact will be adjusted and exhibited three-dimensionally in all four
Fig. 7. Overlapped processes in an ECG
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
785
Fig. 8. The CORBA model.
machines without stopping the tasks the designers are currently performing. 7. Closure The rule-based approach from traditional AI and the conventional constraint satisfaction algorithms are not adequate to cope with the unpredictable events and interactive computation in distributed CAD environments. In this paper, the authors explore new possibilities for distributed CAD systems based on the concepts of emergence, reactivity, and online algorithms. Furthermore, a more pragmatic view of emergence is proposed. The constraint relationships between agents in the ECGs can be nonlinear and the graph can be cyclic. The problem of constraint satisfaction in cyclic graphics is not trivial and the search for ef®cient algorithms is still an open issue [26,27]. The present paper presents a solution for the nonlinear constraint problem in cyclic graphs, which are distributed over a heterogeneous network. The relationships between agents in an ECG are generic, distributed, recursive
and nonlinear. The authors are not aware of any other online algorithm with these characteristics in the literature. This paper presents an effective solution for the problem of distributed recursion. References to distributed recursion are scarce. Florin et al. [28] de®ned an interesting framework for writing recursive distributed algorithms called `distributed recursive waves'. However, their solution does not support online algorithms. Although powerful, ECGs are not ef®cient. However, the performance analysis of online algorithms, a new and dif®cult area of research, is not in the scope of the present paper. Albers [8] suggests evaluating the performance of an online algorithm using competitive analysis. In a competitive analysis an online algorithm A is compared to an optimal of¯ine algorithm, which is a reference of minimum cost. In this technique, given a request sequence s, the online algorithm A is called c-competitive if and only if there is a constant a such that: CA s # c:COPT s 1 a Where CA(s) is the cost of A, COPT(s) is the cost of the
Fig. 9. An ECG containing a variable with 2 hyper-edges.
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787
786
Table 1 Tolerance vs. recursion level for the ECG of Fig. 9 Tolerance
Maximum level of recursion
0.3 0.1 0.05 0.001 0.0005 0.00001 0.000005
11 15 16 28 53 53 53
optimal of¯ine algorithm, c is called the competitive rate of A, and s is the sequence s(1), s(2),¼ Some trivial experiments show that the algorithm proposed in this paper is strongly in¯uenced by numerical tolerance. Fig. 9 presents an ECG containing a variable with two hyper-edges, which was tested with several tolerances. The results of the numerical tolerance tests are presented in Table 1. The ECGs can easily be used to introduce intervals for speci®c variables. Fig. 10 illustrates the case where the height of a box should be in the interval (a, b). The purpose of an ECG is not the search for an optimal solution, as it is the case of traditional constraint satisfaction algorithms. The objective of an ECG is to provide a qualitative and sensitivity analysis of the behavior of a society of reactive agents. From the viewpoint of interactive computation, there is here a contrast with traditional mathematical programming, similar to the opposition of emergence to conventional `arti®cial intelligence'. In both cases one can recognize an opposition against pure of¯ine algorithmic computation, which cannot cope with the surprises, creative moments and ongoing history of the design processes. This paper presents a complete work, from concepts up to algorithms and distributed computing solutions. However, the subject is vast and further work is required. The main line for future work is to investigate the performance of the
Fig. 10. Variable h within (a,b).
ECGs in real applications in design. Also future work should be done to develop a model of negotiation between agents for the establishment of the initial sets of constraints. Acknowledgements The authors would like to thank CNPq, Brazil, and FCT, Portugal, for their ®nancial support. Thanks are also due to Renato Cerqueira for his support in LuaOrb. References [1] Spatial Technology, ACIS 3D Toolkit Version 5.0 (manuals). Spatial Technology Inc., Boulder, CO, 1999. [2] Siegel J. CORBA Fundamentals and Programming. New York: Wiley, 1996. [3] Porter S. What's up with ACIS? Comput Graph World 1995;18(9):30±6. [4] Regli WC. Intranet-enabled Computer-Aided Design. IEEE Internet Comput 1997;1(1):39±50. Also in http://www.computer.org/ internet/ backissu.htm [5] Feijo B, Bento J. A logic-based environment for reactive agents in intelligent CAD systems. Adv Engng Software 1998;29(10):825±32. [6] Gomes PCR, Feijo B, Cerqueira R, Ierusalimschy R. In: Horvath I, Taleb-Bendiab A, editors. Reactivity and pro-activeness in virtual prototyping, 2nd Int Symposium on Tools and Methods for Concurrent Engineering,TMCE'98, 21±23 April. Manchester, UK: Manchester Metropolitan University, 1998. p. 242±53. [7] Feijo B, Gomes PCR, Bento J, Scheer S, Cerqueira R. Distributed agents supporting event-driven design processes. Gero JS, Sudweeks F, editors. Arti®cial Intelligence in Design '98 1998:557±77. [8] Albers S. Competitive online algorithms. Optima Ð Mathl Program Soc Newsl 1997;54(June):1±8. [9] Irani S, Karlin AR, On online computation, http://www.ics.uci.edu/ ~irani/Online/Online.html [10] Holland JH. Emergence: from chaos to order. Cambridge, MA: Perseus Books, 1999. [11] Minsky ML. The society of mind. London: Pan Books, 1988. [12] Brooks RA. A robust layered control system for a mobile robot, Technical Report A.I. Memo 864. Cambridge, MA: Arti®cial Intelligence Laboratory, MIT, 1985. [13] Brooks RA. Elephants don't play chess. In: Maes P, editor. Designing autonomous agents: theory and practice from biology to engineering and back. Cambridge, MA: MIT Press, 1990. p. 3±15. [14] Brooks RA. Intelligence without reason, A.I. memo 1293. Cambridge, MA: Arti®cial Intelligence Laboratory, MIT, 1991. [15] Brooks RA. Intelligence without representation. Artif Intell 1991;47:139±59. [16] Forrest S. Emergent computation. In Proceedings of the Ninth Annual International Conference of the Center for Nonlinear Studies on Selforganizing, Collective, and Cooperative Phenomena in Natural and Arti®cial Computing Networks, Los Alamos, NM, May 22±26. North Holland, 1989. [17] Chalmers DJ. Thoughts on emergence, Newsgroup communication, comp.ai.philosophy, 6 Oct 90, in siteling.ucsc.edu/~chalmers/notes/ emergence.html, last access in 4 Jun 1999. [18] Simon HA. The sciences of the arti®cial. 2nd ed. Cambridge, MA: MIT Press, 1981. [19] Reynolds C. Flocks, herds and schools: a distributed behavioral model. Comput Graph 1987;21:25±34. [20] Wagner P. Why interaction is more powerful than algorithms. Commun ACM 1997;40(5).
B. Feijo et al. / Advances in Engineering Software 32 (2001) 779±787 [21] Fodor JA, Pylyshyn ZW. Connectionism and cognitive architecture: a critical analysis. Cognition 1988;28:3±71. [22] Kumar V, Grama A, Gupta A, Karpis G. Introduction to parallel computing: design and analysis of parallel algorithms. Benjamin/ Cummings, 1994. [23] Raynal M. Distributed algorithms and protocols. New York: Wiley, 1992. [24] Ierusalimschy R, Figueiredo LH, Celes WF. Lua Ð an extensible extension language. Software: Pract Exper 1996;26(6):635±53. Also see http://www.tecgraf.puc-rio.br/lua/. [25] Cerqueira R, Rodrigues N, Ierusalimschy R. Binding in interpreted language to CORBA, SimpoÂsio Brasileiro de Linguagens de ProgramacËaÄo 1997 p 23±36.
787
[26] Zanden BV. An incremental algorithm for satisfying hierarchies of multiway data¯ow constraints. ACM Trans Program Lang Syst 1996;18(1):30±72. [27] Tsai YT, Fernando T, Dew PM. Exploiting degrees of freedom analysis for interactive constraint-based design, Technical report 95.36. UK: School of Computer Studies, University of Leeds, 1995. [28] Florin G, Gomez R, Lavalle I. Recursive distributed programming schemes, Proceedings ISADS'93: International Symposium on Autonomous Decentralized Systems. Kawasaki, Japan: IEEE Computer Society, 1993, pp 122±8.