Practical: An HTML Generation Library, the Compiler

Archaeological stratigraphy-datasets are widely represented and visualised by the Harris Matrix. However, even digital Harris matrices retain most of the limitations their paper originals experienced and they are still in need of a standardised format for automatic recording. This paper presents an example, based on the well-known CSV open format, with a Data Package descriptor. The Harris Matrix Data Package standard is the result of two independent software implementations, one in Common Lisp by T.S. Dye and one in Python. The proposed format is not limited to describing the stratigraphy for the sole purpose of generating a diagram to look at, but it can be used to model stratigraphy as a Directed Acyclic Graph and to guide the interpretative process and integrate the results with established procedures for Bayesian modelling.

The purpose of research is to analyze and use metaprogramming in the Common Lisp language when designing and implementing emulators that simulate computer system hardware. The metaprogramming, the macro tools of the Common Lisp language and the use of macros for metaprogramming are considered.Methods. The Lisp language is characterized by its use of uniform S-expressions to represent data and programs. Thus, data can be part of a program and vice versa: a program can be data. Common Lisp macro tools allow you to directly modify the abstract syntax tree of a program, and thus it is possible to create new syntactic constructs to solve a given problem. When implementing emulator functions, macro tools of the Common Lisp language can be used to generate functions, where the common part of the functions is included in the macro, and the differences between the functions are specified in the parameters when calling the macros. Examples of this macros are: bit status register macros, generation of ariphmetic commands, comparation commands, memory commands. Using that you can significantly reduce the size of the program.Results. As a result of computer modeling, a simulator of the NES architecture (MOS 6502 processor) was developed and implemented in the conventional object-orientied C# programming language and in the Common Lisp metaprogramming language. As a result, the simulator written in a language with metaprogramming support turned out to be more than 2 times smaller than the simulator written in C#.Conclusion. The use of metaprogramming (using the example of creating emulators) can significantly reduce the size of a program, simplify and improve the program architecture, reduce the number of errors and improve the quality of programs. The use of domain specific languages lets reduce code size even more.

As program behavior becomes complex, it’s increasingly important to analyze their behavior statistically. The article describes two separate but synergistic tools for statistically analyzing large Lisp programs. The first tool, called CLIP (Common Lisp Instrumentation Package), allows the researcher to define and run experiments, including experimental conditions (parameter values of the planner or simulator) and data to be collected. The data are written out to data files that can be analyzed by statistics software. The second tool, called CLASP (Common Lisp Analytical Statistics Package), allows the researcher to analyze data from experiments by using graphics, statistical tests, and various kinds of data manipulation. CLASP has a graphical user interface (using CLIM, the Common Lisp Interface Manager) and also allows data to be directly processed by Lisp functions. Finally, the paper describes a number of other data-analysis modules that have been added to work with CLIP and CLASP.

A reader has asked for suggestions on how to write Common Lisp programs so that they can in the future be translated into Scheme without too much difficulty. Someone else wants to write programs in Scheme that might eventually be translated into Common Lisp. These are interesting questions, but a related question is more immediate: How do you write programs in Scheme that can easily be translated to run in other implementations of Scheme?

We consider the problem of learning complex recursive rules which involve new concepts other than those given in the input relations and which must be discovered by the learning algorithm in the course of finding rules. The existing learning methods (FOIL, FORGE, and etc.) create rules based on the given concepts or relations but they cannot create new concepts. However, in many cases one must use new intermediate concepts in order to form the recursive rules. We give a new technique for constructing such intermediate concepts and learning rules based on those concepts. We illustrate the new technique with several examples, none of which can be handled by the existing methods. We have implemented the new technique in Common Lisp and tested many different examples.

John McCarthy designed the LISP programming language for the symbolic computation typical of artificial intelligence at the time, and LISP was strongly associated with AI at least through the 1990s. By 1963, a number of ideas had been proposed for how LISP 1.5 could be improved and extended. This lead to the LISP 2 project, which was carried out at System Development Corporation by personnel from SDC and Information International, Inc., using the military AN/FSQ-32 computer. LISP 2 extended LISP 1.5 with ALGOL-like syntax, static type checking, efficient support for arithmetic and arrays, pattern-matching, and more, but the LISP 2 language failed to displace LISP 1.5. Despite this, LISP 2 foreshadowed later languages, such as ECL, Common Lisp, and Java. An online archive of LISP 2 documents and source code exists at the Computer History Museum, providing a snapshot of mid-1960s ARPA-funded research and development.

Our experience in using the RTGIL tools has shown that these tools and the graphical representation of the logic are very helpful for specifying and verifying properties of concurrent real-time systems. In addition to the aircraft example, we have used these tools to specify and verify properties of a railroad crossing system, a robot, an alarm system, and a four-phase handshaking protocol.The RTGIL tools are implemented in Lucid Common Lisp and also in Franz Allegro Common Lisp, and require at least 32 MBytes of main memory and 64 Mbytes of swap space. The graphical editor was implemented using the Garnet graphics toolkitKeywordsDecision ProcedureTheorem ProverSearch PatternEditing OperationGraphical EditorThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

: We ported the Portable Standard Lisp compiler to MIPS-X, a reduced-instruction-set processor. In this paper we report on a number of profiling measurements made on a set of 11 LISP programs. The measurements give information on two levels. Because the instruction set of MIPS-X contains only very simple, basic instructions the profiling information is at avery low level. In a second group of measurements, we determine how much time each program spends on most common primitive LISP operations. Because MIPS-X executes all machine instructions in a single cycle, it is possible to get very accurate timing measurements by instruction counts. (Author)

Twelver Shiite dogma, it has already been noted, affirms a precise balance between the external and internal dimensions of Scripture. For the good of society as a whole, an individual's spiritual insights into the hidden purport of sacred writ cannot take precedence over the law articulated in the literal text. Batin and zahir share equal validity.KeywordsPrecise BalanceLove PoemRitual PrayerDivine WisdomBedouin TribeThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

To assess how much faster Lisp programs would run on large multiprocessor systems, several application kernels were modified for parallel execution and simulation of their behavior. The kernels exhibited speed-ups ranging from one to 850 times faster, suggesting that the technique is of no value to a few programs, of great value to a few programs, and of moderate value to most programs. The modifications were originally done manually but now are accomplished by a program. Further manual editing may yield even more parallelism.KeywordsParallel ExecutionRecursive CallParallel EnvironmentMemory CycleApplication KernelThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

CHAPTER 4 - GPS: The General Problem Solver

The authors have conducted a series of benchmark studies on two implementations of a Cockpit Information Management system. Each implementation uses three different data support structures to determine the performance effects of changing the underlying data representation in a specific Blackboard system implementation. A third implementation, also discussed briefly, is a Common LISP program which addresses the Cockpit Information Management (CIM) domain directly using arrays as the data representation structure. A strong case is presented for the use of a particular data support structure based upon the type of application being implemented by the blackboard system. It is shown that a system that has a frequent need to sort objects by their attributes, benefits from the use of a data support system that provides efficient access to the blackboard objects based upon their attribute values. The choice of an indexing support is similar to the decision during relational database design to index a particular field in a relation. The CIM application has benefitted from the use of a support structure that allows the use of indexed attributes because it allows the application to do many fewer blackboard reads and writes than would otherwise be required. The Boeing Company has been using Blackboards to develop prototype Cockpit Information Management systems for several years. The Blackboard model was chosen because of its inherent flexibility which has been useful in our efforts to define the function of a Cockpit Information Manager. In the course of this work we have been prototyping the functions to be performed by advanced Pilot Vehicle Interfaces (PVIs) and have identified benefits from using prototypes that react quickly to pilot inputs and other external events. We have revised our designs repeatedly in order to improve the performance of our prototype PVIs while retaining flexibility in our development environment [l].As our systems have become more robust, and the CIA1 domain has become more precisely defined, tllc need to address performance issues has become more critical. This work presents some timing measurements for a previous revision and a current prototype with our analysis of why the current prototype runs more quickly, and includes some general observations concerning the optimization of blackboard applications based upon the types of tasks the application performs.

This paper describes the BL addressing mode and the address tag in FLATS2 machine, which is a general-purpose MIMD computer now under construction. The BL addressing mode integrates memory accessing and range checking by hardware. Address tag is a bit in word, which indicates the capability for memory access. Combining them together, efficient memory protection is provided at run-time. It reduces the cost of run-time type checking in Lisp by checking the address tag and the address of a pointer against the range of the region associated to a type, in parallel with the memory access. The arithmetic instructions check the address tags of operands to support the generic arithmetic in Lisp. We can also make use of this scheme to check the number of arguments and multiple return values and to check array-bounds to support faster execution of Common Lisp program. These facilities are not specific to Lisp, so that they can be used more generally than other tagged architectures.

No abstract available.

The design and implementation of a Distributed, Operating System based, Blackboard Architecture for Real-Time control (DOSBART) is described. DOSBART demonstrates the outstanding applicability of AI languages and blackboard techniques to the construction of versatile distributed real-time control frameworks. It provides a means to remotely and transparently execute operations on non-local objects, furnishing the ability to share data and blackboard structures transparently across a network of heterogeneous computers. It allows the simultaneous execution of all blackboard activities by utilizing the underlying operating system's multi-process functionality rather than its own scheduling mechanism. Architectural features are incorporated to deal with distributed real-time control issues such as interrupts, data dependencies, resource contention, activity control and I/O. Computation may occur in both process based and message based perspectives, and may be driven by a first order theorem prover that dynamically infers triggering events, by changes in demoned datums or by arbitrary predicates. The representational capabilities of the Common Lisp Object System (CLOS) were exploited to provide a rich set of base classes from which specific applications can be tailored. Lisp macro facilities support for multiple platforms.