UCL+P—Defining and Implementing Persistent Common Lisp

The Persistent Lisp language was defined and an implementation, UCL+P, 1 was designed and constructed. Persistent Lisp is a superset of Common Lisp which fully supports the development of programs manipulating persistent data while maintaining Lisp semantics across the storage/retrieval of values. Persistence features provided are concurrent atomic transactions, demand loading of values, and transparent load and store of persistent values. All Common Lisp data types (with the exception of streams) can be made persistent. Nonsymbolic values are initially created as transient values on the runtime heap. When a transaction completes, transient values which are reachable from a persistent symbol become persistent. The package mechanism has been extended to add a persistence attribute to packages. When symbols are interned in a package with the persistence attribute, they become persistent, as do values reachable from them. UCL+P was created to support these features, by making extensive low-level modifications to the UCL compiler and runtime system. A new runtime data structure, the indirection vector, was created to support the relocation of newly persistent values from the runtime heap to the persistent heap.     

JDO实例的状态管理研究

Java Data Objects(JDO)是在Sun公司倡导下制定的新的Java对象级别的透明持久化标准。JDO关注于那些代表着应用领域数据模型的Java类，它们代表的数据要被持久存储到各种数据源，这些类被称为可持久类，它们的实例被称为可持久实例或JDO实例。JDO实例分为瞬时的和持久的，代表着数据源中数据的JDO实例为持久的，它们已经与数据源中的数据发生关联；否则就为瞬时的。JDO必须使持久JDO实例的值与相应数据源中的数据保持同步，因此有了JDO实例的状态管理，包括JDO实例的生命周期状态管理和JDO实例的字段管理。该文的重点是对JDO实例的状态管理进行研究。对相关规范进行了深入分析，并讨论了具体的实现方法。     

Lazy task creation: a technique for increasing the granularity ofparallel programs

When a parallel algorithm is written naturally, the resulting program often produces tasks of a finer grain than an implementation can exploit efficiently. Two solutions to the granularity problem that combine parallel tasks dynamically at runtime are discussed. The simpler load-based inlining method, in which tasks are combined based on dynamic bad level, is rejected in favor of the safer and more robust lazy task creation method, in which tasks are created only retroactively as processing results become available. The strategies grew out of work on Mul-T, an efficient parallel implementation of Scheme, but could be used with other languages as well. Mul-T implementations of lazy task creation are described for two contrasting machines, and performance statistics that show the method's effectiveness are presented. Lazy task creation is shown to allow efficient execution of naturally expressed algorithms of a substantially finer grain than possible with previous parallel Lisp systems     

Endpaper: Technical issues of separation in function cells and value cells

Summary The bulk of arguments that focus on clean semantics and notational simplicity tend to favor uniting the function and value namespaces. In spite of this, there are those who hold strongly to a belief that a two-namespace system affords useful expressive power that they are unwilling to do without. In the end, practical considerations favor the status quo for Common Lisp. There are a large number of improvements beyond a single namespace that could be made to Common Lisp that would clean it up and simplify it. We feel that the time for such radical changes to Common Lisp has passed, and it is the job of future Lisp designers to take the lessons from Common Lisp and Scheme to produce an improved Lisp.This paper is an adaptation of a report produced for X3J13 by the authors, a technical working group engaged in standardizing Common Lisp for ANSI.     

An algebraic specification of method combination for the Common Lisp Object System

The Common Lisp Object System (CLOS) is an extension of Common Lisp for object-oriented programming being designed as part of the ANSI X3J13 Common Lisp standardization process. This report describes an algebraic specification of the method combination and application component of CLOS. The specification is based on a draft of the standard presented to the ANSI committee in spring of 1987, and was done using an executable, typed functional programming language called Axis. The result suggests a logical mapping from the abstract data types and operations in the specification to the classes and methods which could become that part of the CLOS kernel (called the metaobject protocol) involved in method combination. In addition, the existence of a formal algebraic specification for CLOS allows the effects of changes in the language to be tested during the design phase, rather than during implementation. This is illustrated by showing how the language semantics change when thecall-next-method function is allowed to take arguments, an extension proposed in the draft standard. Standardization documents like the CLOS standard are usually written in a semi-natural language, but if they are accompanied by an additional formal specifiction during their generation, the probability of undetected or lately discovered errors in the design decreases, and the specification also provides an unambiguous source of reference for implementors.     

Overview: The common lisp object system

The Common Lisp Object System is an object-oriented system that is based on the concepts of generic functions, multiple inheritance, and method combination. All objects in the Object System are instances of classes that form an extension to the Common Lisp type system. The Common Lisp Object System is based on a meta-object protocol that renders it possible to alter the fundamental structure of the Object System itself.     

A verified Common Lisp implementation of Buchberger’s algorithm in ACL2

In this article, we present the formal verification of a Common Lisp implementation of Buchberger’s algorithm for computing Gröbner bases of polynomial ideals. This work is carried out in ACL2, a system which provides an integrated environment where programming (in a pure functional subset of Common Lisp) and formal verification of programs, with the assistance of a theorem prover, are possible. Our implementation is written in a real programming language and it is directly executable within the ACL2 system or any compliant Common Lisp system. We provide here snippets of real verified code, discuss the formalization details in depth, and present quantitative data about the proof effort.     

Adaptive Action for Multi‐Agent Persistent Coverage

Persistent coverage with a team of agents refers to the task of covering an area where the coverage degrades with time. This is a dynamic task as opposed to the deployment problem. A key issue here is the coverage degradation that prevents the complete coverage fulfilment and requires persistence in the action. We propose a new method for persistent coverage where the agents' actions are computed in a partially distributed manner. The contribution is a control strategy based on variable coverage action and variable coverage range of the agents. This control provides adaptive behaviour in terms of actuator power and actuator domain in order to reduce the coverage error and energy consumption. The proposal is tested in simulation, showing clear improvement in terms of efficiency, flexibility, and scalability.     

A synergistic model-driven approach for persistence modeling with UML

The Model Driven Development (MDD) approach proposes that models (and model-to-model transformations) play the main role on system development. However, there is not a consensual notation to model persistence based upon object-relational mapping frameworks: while UML lacks specific resources for persistence modeling, the entity-relationship model does not make reference to the dynamic concepts existing in UML.This paper proposes MD-JPA, a UML profile for persistence modeling based on the well-known Java Persistence API 2 (JPA) standard for object-relational mapping, pursuing the modeling of transient and persistent elements in a more coherent and synergistic way. This paper describes the main characteristics of MD-JPA as well as the way that models that adopt such profile can them be used to generate a Java implementation by the application of the proposed model transformations on a MDD approach. Finally, an open source tool was developed to make the results of this work available to the community.     

Landscape visualization with Emaps

Emaps, a comprehensive environment for displaying geographic data, written in object-oriented Common Lisp and running on a Macintosh computer, is described. In Emaps, a hierarchy of objects-windows, maps, cells-takes advantage of the class-instance inheritance and generic methods of Common Lisp to allow prototyping and exploring of variations. The combination of a class library of objects, a protocol for accessing them, ready access to the full display capabilities of the computer, and the interpreted nature of Lisp make for an interactive environment for visualizing landscapes and exploring geographic information