Common Lisp Object System Research Articles

MATHEMATICAL ECOLOGICAL ANALYSIS OF SIMILARITIES AND DIFFERENCES IN TOWNSCAPES

The purpose of this research is to read the pattern of Similarities and Differences in traditional townscapes in Kyoto using Common Lisp Object System (CLOS). First we extract the distribution of signs in townscapes in terms of architectural signs, their materials and finish, from the database of townscapes, which we construct on CLOS. Then we analyze the mechanism of Similarities and Differences quantitatively by diversity index, which is used as a measure of species diversity in the field of mathematical ecology. As the result, we clarify that the patterns of Similarities and Differences are realized in multiple levels, such as distribution of signs in the whole townscape, that in each facade of a house, and distribution of facade types.

Multimethods in C++ using recursive deferred dispatching

The author proposes a new approach for multimethod implementation in C++ based on recursive deferred dispatching. The proposed approach provides a partially broken dependency between target classes and a broken dependency between target classes and multimethods. This approach provides multimethods with strong type safety and constant execution time. A multimethod is a virtual method of several objects. Programming languages such as Dylan and the Common Lisp Object System (CLOS) allow for multimethods.

Effective homology of a classifying space

Sergeraert defines in [9] a method to solve the main problems of Constructivism in Algebraic Topology. The first resulting computer program, E.A.T., showed this method is a usable concrete framework for a Constructive Algebraic Topology implementation [8].Rubio and Sergeraert solved in this way an important but particular problem: computing the homology of iterated loop spaces. The application field of the EAT program is rather limited, despite its interesting results. Implementation of mathematical categories in Lisp has met real difficulties and it looked unreasonable to plan a general Constructive Algebraic Topology program along the same line.The OOP Lisp implementation CLOS (Common Lisp Object System) provides a powerful means of implementing these categories. The new program Kenzo also implements Sergeraert's method for Constructive Algebraic Topology, but the scope is considerably larger [11]. In particular the Kenzo program allows one to compute the first homotopy groups of an arbitrary simplicial set. It is the first computer program able to solve this problem; new homotopy groups have been calculated in this way.

Computer-Assisted Composition at IRCAM: From PatchWork to OpenMusic

In recent years, IRCAM has been exploring and developing software for computer-assisted composition (CAC). These software packages allow composers and musicologists to formalize and experiment with the structures and dynamics of musical languages. The Formes program (Rodet and Cointe 1984), although primarily devoted to the control of sound synthesis, was really a compositional environment with a high-level object-oriented architecture. The Crime environment (Assayag, Castellengo, and Malherbe 1985; Amiot, Assayag, Malherbe, and Riotte 1986) was the first attempt at IRCAM to realize a general CAC environment where the user could define and control abstract musical formalisms. Francis Courtot developed CARLA as an attempt to use a visual programming interface to a Prolog-based logic-programming system (Balaban, Ebcioglu, and Laske 1992). The development of the PatchWork environment, by M. Laurson, J. Duthen, and C. Rueda (Laurson and Duthen 1989; Laurson 1996), was the next stage in the development of CAC programs at IRCAM. The combination of programming simplicity and a highly visual interface in a personal computing concept created an infatuation with PatchWork among European composers with highly diverse musical and aesthetic backgrounds, including Antoine Bonnet, Michel Fano, Brian Ferneyhough, Gerard Grisey, Paavo Heininen, Magnus Lindberg, Claudy Malherbe, Tristan Murail, Kaija Saariaho, and many others. OpenMusic, designed by G. Assayag and C. Agon (Assayag, Agon, Fineberg, and Hanappe 1997; Agon, Assayag, Delerue, and Rueda 1998), is the most recent IRCAM CAC environment. It is a visual interface to CLOS, the Common Lisp Object System (Steele 1990). Aside from being a superset of PatchWork, it opens new territories by allowing the composer to visually design sophisticated musical object classes. It introduces the maquette concept, which enables high-level control of musical material over time, and it revises the PatchWork visual language in a modern way.

Complex fans

If we allow the magnitude and angle of a complex number (expressed in polar form) to range over an interval, it describes a semicircular region, similar to a fan; these regions are what we call complex fans. Complex numbers are a special case of complex fans, where the magnitude and angle are point intervals. Operations (especially addition) with complex numbers in polar form are complicated. What most applications do is to convert them to rectangular form, perform operations, and return the result to polar form. However, if the complex number is a Complex Fan, that transformation increases ambiguity in the result. That is, the resulting Fan is not the smallest Fan that contains all possible results. The need for minimal results took us to develop algorithms to perform the basic arithmetic operations with complex fans, ensuring the result will always be the smallest possible complex fan. We have developed the arithmetic operations of addition, negation, subtraction, product, and division of complex fans. The algorithms presented in this article are written in pseudocode, and the programs in Common Lisp, making use of CLOS (Common Lisp Object System). Translation to any other high-level programming language should be straightforward.

Implementing neural firing: Towards a new technology

Following earlier work on neural firing and synthesis, we use the expressions we derived elsewhere in the literature for that purpose, to show how we can represent images and sounds with the aid of CLOS (Common Lisp Object System) computer program of the LISP computer language.

CLOSe to the edge? Advanced object‐oriented techniques in the representation of musical knowledge*

The modeling of knowledge about musical expression asks for quite some flexibility during the design process and for the availability of high‐level abstractions to represent successfully the complex concepts and their interactions in this domain. One would expect, because of the enthusiastic claims made in the literature on object‐oriented programming, that such an approach would be ideal for this task. This paper describes some aspects of the Common Lisp Object System (CLOS), a modern object‐oriented language that indeed provides some advanced constructs that proved useful in the design and maintenance of a complex system for the manipulation of expression in music. However, some of the mechanisms should be used with care to stay far from the point beyond which programs become too complex to grasp.

Collaborative version control in an agent-based hypertext environment

In this work we discuss a number of issues for the design of hypertext systems in an agent-based model of computation. We examine how the “traditional” fundamental concepts which are at the basis of the design of hypertexts can be re-visited under a new perspective of collaborative expert agents. The paper presents how some principles of high-level concurrent programming are applied as new methodologies for the design and development of complex software, such as hypertext systems. By adopting an agent-based framework, we gain powerful control on version management that presents considerable difficulties for the development of hypertext systems; a general distributed version control mechanism is applied, without significant differences, both in single-user and in collaborative multiuser mode. In both cases, the underlying hypertext architecture is defined in terms of computational agents interacting each other in order to accomplish common goals. In this paper we present a first-level prototype implemented in a concurrent object-oriented language, realized on the top of the Common Lisp Object System.

The Opla System: Designing Complex Systems in an Object-oriented Logic Programming Framework

This paper describes the OPLA language, an object-oriented (OO) logic programming language layered on Common Lisp Object System. OPLA allows the benefits of the OO approach to the design, organization and realization of large logic programs thanks to an OO programming environment. Thanks to a deep link with the underlying CLOS language, OPLA offers important features of the OO paradigm, such as multiple inheritance, multi-methods (multi-argument discrimination) and constraint-based control flow mechanism. These characteristics play an important role in OO Prolog programming, improving the readability of the code and augmenting the maintainability of the applications. This paper presents the OPLA language and some experiences resulting from the design and implementation of graphic interfaces which have been realized in OPLA itself. The OPLA programming style facilitates the management of some difficult problems which are basic issues of user-interface development, such as the management of graphical constraints on windows, the distinction of specifying the graphics of objects from their behavior, and law-based delegation. The implementation methodology which was adopted to realize the bulk of the OPLA system is completely independent of hardware constraints; it exploits an incremental, abstract implementation technique based on a high-level generator mechanism. Our approach has been evaluated both in terms of software design and in terms of overall performances. The novel features of OPLA are quantitatively discussed by reporting their impact in the realization of the significant applications.

Reflections on metaprogramming

By encapsulating aspects of language semantics within a set of default classes and allowing the programmer to derive new versions, object-oriented languages whose semantics can be tailored to the needs of individual programmers have been provided. The degree to which such languages are simultaneously flexible and efficient is an open question. We describe our experience with using this technique to incorporate transparent support for persistence into the Common Lisp Object System via its metaobject protocol, an open implementation based on reflection. For many aspects of our implementation the metaobject protocol was perfectly suitable. In other cases we had to choose between extending the protocol, requiring the application programmer to employ special idioms, and tolerating a large performance penalty. Based on our experience we evaluate the metaobject protocol, propose some improvements and extensions, and present performance measurements that reveal the need for improved language implementation techniques.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

DESIGNING COMPLEX SYSTEMS WITHIN DISTRIBUTED ARCHITECTURES: AN INTELLIGENT TUTORING SYSTEMS PERSPECTIVE

The goal of this work is to introduce the basic concepts of distributed artificial intelligence as new methodologies to conceive and realize complex intelligent systems. We focused our attention on the design of intelligent tutoring systems, and using a distributed framework, we reached a fine control on the communicability process, one of the key issues in the realization of intelligent tutoring systems. A prototype is presented as an open information system in which classical modules, such as the domain expertise module and the tutor, are seen as populations of intelligent actors that share their fragmentary knowledge and organize their tasks in a concurrent universe in order to accomplish a common goal, the teaching session. The system has been written in a concurrent object-oriented language, realized on top of the Common Lisp Object System.

Object-oriented programming: the CLOS perspective

To date, books on object-oriented programming have tended to focus either on the methodology of the object-oriented paradigm or on teaching the details of a particular programming language. This collection takes a different approach, examining one object-oriented programming language - the Common-Lisp Object System (CLOS) - as a modern programming tool. The 14 contributions examine CLOS from a variety of angles, revealing the thoughts behind the design of the language, its intended use, its impact on object-oriented design and programming and its place in the context of other object-oriented programming languages. Chapter 1 provides enough detail about the language for the remaining material to be understood by readers unfamiliar with CLOS, and it concentrates on the unusual aspects of the language. CLOS is placed into historical perspective in Chapter 2, which describes the sources and evolution of ideas embodied in the language. Further chapters discuss the metaobject protocol, compare CLOS with other object-oriented languages, and discuss applications of the language and aspects of its implementation.

An Interactive Graphic Model of a Human Body and 3-Dimensional Free Space between a Garment and a Body for Garments Design.

An interactive graphic human body model was developed as a hierarchical structure. The model consist of torso, arms, legs and other body parts. Various postures of the model can be controlled through a natural language interface which is parsed by definite clause grammar and the database of the human body model made by Common Lisp Object System (CLOS). Especially, the torso component, which are the most important in the garment design, can be controlled and expressed more precisely.A 3-dimensional free space between a garment (blouse of the 9AR type) and a body was measured and expressed visually by computer graphics. Two kinds of blouse of the 9AR type were made and put on the dressmaker's model equivalent to the graphic body model. The results showed that the 3-dimensional free space expressed by the computer graphics is useful in clothing engineering.

Simulation modelling of a manufacturing enterprise with complex material, information and control flows

Abstract This paper describes practical problems encountered in modelling and simulating complex system interactions in a manufacturing enterprise. In addition to production, the interactions of diverse activities such as sales forecasting, order processing, production planning, material requirements planning, material procurement and distribution are considered. The preliminary results of such modelling and simulation are described. A graphical model of the order-to-ship (OTS) process, which consists of the activities that occur between the receipt of orders and the shipment of products within a factory, was built using hierarchical process modelling (HPM), derived from IDEF-0. Simulation model components for the OTS process were built using object-oriented programming and discrete-event simulation concepts. These reusable components were implemented in the class structure of the common Lisp object system (CLOS) within a manufacturing enterprise simulator (MES), on which different manufacturing enterpris...

SENEX; CLOS/CLIM in biomedical education

SENEX is a computer application in its fifth year of development focused on representation of molecular information, presentation of data, and reasoning with molecular information. It is written in a portable programming environment supported by Common Lisp, the Common Lisp Object System (CLOS), and the Common Lisp Interface Manager (CLIM). SENEX contains information about molecules, molecular events and disease processes, and provides tools for reasoning with and displaying this information in useful ways. This paper describes the architecture of SENEX and how that architecture facilitates development of a set a computer tools for education and research in molecular pathology. Several examples of how an individual might currently use SENEX to explore information related to the molecular basis of Alzheimer's disease are illustrated.

A tutorial on LISP object-oriented programming for blackboard computation (solving the radar tracking problem)

This exposition is a tutorial on how object-oriented programming (OOP) in LISP can be used for programming a blackboard. Since we have used Common LISP and the Common LISP Object System (CLOS), the exposition demonstrates how object classes and the primary, before, and after methods associated with the classes can be used for this purpose. the reader should note that the different approaches to object-orient programming share considerable similarity and, therefore, the exposition should be helpful to even those who may not wish to use CLOS. We have used the radar tracking problem as a “medium” for explaining the concepts underlying blackboard programming the blackboard database is constructed solely of classes which act as data structures as well as method-bearing objects. Class instances form the nodes and the levels of the blackboard. the methods associated with these classes constitute a distributed monitor and support the knowledge sources in modifying the blackboard data. A rule-based planner is used to construct knowledge source activation records from the goals residing in the blackboard. These activation records are enqueued in a cyclic queueing system. A scheduler cycles through the queues and selects knowledge sources to fire. © John Wiley & Sons, Inc.

Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991)

Object oriented programming (OOP) is a primary feature of many popular AI tools. The Art of the MetaObject Protocol is by the principal creators of the Common Lisp Object System (CLOS), probably the best conceived and most flexible of today's object oriented languages. This book is an annotated walk-through of the implementation of a subset of CLOS the authors call Closette. The authors are all from Xerox PARC.

Two models of object-oriented programming and the Common Lisp Object System

Two models of object-oriented programming and the Common Lisp Object System

Visualization and graphical layout in object-oriented systems

This paper describes two aspects of visualizing program systems within the object-oriented paradigm: layout specifications for graphical objects and associations of visualization and application objects. The layout approach is based on a notation similar to the T EX text formatting language. It has been extended and generalized for specifying graphical layout of user interfaces and arbitrary objects. Our simplest scheme offers specifications similar to T EX's box-and-glue metaphor. Size and position of virtual boxes and glue can be specified by simple constraints. In the second part of the paper we show how the CLOS (Common Lisp Object System) meta-level architecture can be exploited to associate visualization and application objects. We show how several useful techniques such as indirect values, slot and method demons, and instance-specific meta-objects can be implemented using CLOS. These visualization techniques require no source code modifications of application systems. We demonstrate the feasibility of our approach using application domains such as CLOS debugging and constraint systems.

A Knowledge‐Based Structural Analysis Based on an Object‐Oriented Approach

Abstract: Analysis is one of the key issues in realizing complex large structures. In spite of the tremendous accumulation of methods and theories in the field of structural analysis, there is still a need to include newly developed methodologies into analysis codes for production use. This paper describes the initial development of a platform to accommodate the future needs in this area. The system being developed is a knowledge‐based system which first accepts the user's description of an analysis problem, comes up with a suitable analysis method and a corresponding computational algorithm, then develops a program along with input data to solve the problem, and finally gives a result to the user. Program generation is done by selecting appropriate building‐block codes from a program database. To construct a prototype system, a problem solving model called an ‘organizational model’ is introduced, which is developed to imitate the problem solving in a real life. The main part of the system, which functions as described above, is written in CLOS (common LISP Object System), while generated codes are written in either FORTRAN or C++. The performance of the prototype system shows that this approach can be effective.