Computer-aided analysis of structures in interlisp environment

LISP appears to be the language of choice among the developers of knowledge-based expert systems. Analysis of structures in INTERLISP environment is discussed in this paper. An interactive INTERLISP program is presented for analysis of frames which can be used as part of an expert system for computer-aided design of structures. Some of the concepts and characteristics of INTERLISP language are explained by referring to the INTERLISP program.     

Program Reusability through Program Transformation

How can a program written in pure applicative LISP be reused in a Fortran environment? One answer is by automatically transforming it from LISP into Fortran. In this paper we discuss a practical application of this technique-one that yields an efficient Fortran program. We view this process as an example of abstract programming, in which the LISP program constitutes an abstract specification for the Fortran version. The idea of strategy-a strategy for getting from LISP to Fortran-is basic to designing and applying the transformations. One strategic insight is that the task is easier if the LISP program is converted to ``recursive' Fortran, and then the recursive Fortran program is converted to nonrecursive standard Fortran. Another strategic insight is that much of the task can be accomplished by converting the program from one canonical form to another. Developing a strategy also involves making various implementation decisions. One advantage of program transformation methodology is that it exposes such decisions for examination and review. Another is that it enables optimizations to be detected and implemented easily. Once a strategy has been discovered, it can be implemented by means of rewrite-rule transformations using the TAMPR program transformation system. The transformational approach to program reuse based on this strategy has a measure of elegance. It is also practical-the resulting Fortran program is 25 percent faster than its compiled LISP counterpart, even without extensive optimization.     

A Cognitive Model and Computer Tutor for Programming Recursion

This article discusses cognitive models of learning to program recursion and their relation to lessons on recursion in an intelligent computer tutor for LISP programming (the LISP Tutor). The cognitive models are implemented as production systems in which programming skill is characterized as the decomposition of programming goals into subgoals and elementary actions via the application of programming plans. Two sets of learning mechanisms are used in the cognitive models. Analogical problem-solving mechanisms use declarative knowledge of example program solutions to overcome problem-solving impasses. Knowledge compilation mechanisms summarize problem solutions into efficient problem-solving skill. Analyses and simulations of novice and expert programming were used to develop ideal models of the programming knowledge to confer upon students and bugs that characterize common misconceptions. The LISP Tutor uses the ideal models and bugs to guide its interactions with students. Experimental evaluations of the LISP Tutor indicate that it is more efficient and effective than classroom instruction.     

Virtual Symposium on Virtual Mind

When certain formal symbol systems (e.g., computer programs) are implemented as dynamic physical symbol systems (e.g., when they are run on a computer) their activity can be interpreted at higher levels (e.g., binary code can be interpreted as LISP, LISP code can be interpreted as English, and English can be interpreted as a meaninguful conversation). These higher levels of interpretability are called ‘virtual’ systems. If such a virtual system is interpretable as if it had a mind, is such a ‘virtual mind’ real? This is the question addressed in this ‘virtual’ symposium, originally conducted electronically among four cognitive scientists. Donald Perlis, a computer scientist, argues that according to the computationalist thesis, virtual minds are real and hence Searle's Chinese Room Argument fails, because if Searle memorized and executed a program that could pass the Turing Test in Chinese he would have a second, virtual, Chinese-understanding mind of which he was unaware (as in multiple personality). Stevan Harnad, a psychologist, argues that Searle's Argument is valid, virtual minds are just hermeneutic overinterpretations, and symbols must be grounded in the real world of objects, not just the virtual world of interpretations. Computer scientist Patrick Hayes argues that Searle's Argument fails, but because Searle does not really implement the program: a real implementation must not be homuncular but mindless and mechanical, like a computer. Only then can it give rise to a mind at the virtual level. Philosopher Ned Block suggests that there is no reason a mindful implementation would not be a real one.     

Learning production systems from examples

This paper describes a program that learns production systems. The user presents examples consisting of inputs together with the required program output for each. If the productions in their current form would result in the output specified by the user for each input, no learning is needed. Otherwise the program must modify the production system so that it produces the correct output. The productions take arbitrary strings of LISP atoms as input and produce characterizations of them as output. Such a characterization can be as simple as the name of a concept to which the string belongs, but may involve the assertion of many properties and relations describing the input.     

An IKBS implementation

This paper details the practical approaches and solutions taken in the implementation of an INTERLISP programmed knowledge based program. Although some of the solutions used are particular to the specific problem domain of this program, the general pragmatic methods are of wider interest. The program excerpts are given in Pseudo-LISP code.     

ADI: Automatic Derivation of Invariants

Most current systems for mechanical program verification are not fully automatic, since the user himself must provide the intermediate inductive assertions. This paper describes an interactive computer program, called ADI, which automatically generates the needed inductive assertions. ADI is also able to extend partial loop assertions supplied by the user to form complete assertions. The implementation (written in QLISP and INTERLISP) is based on both the algorithmic and the heuristic approaches introduced by Katz and Manna in "Logical Analysis of Programs" [25]. For the algorithmic subsystem ADI includes: Difference Equations Constructor, Difference Equations Solver, and Invariants from Conditional Statements Generator. The heuristic subsystem includes: Exit Rules Package, Bounding Variables Component, Strengthening Executer, Weakening Executer, and a Heuristic Invariant Matcher-which is the actual implementation of two new heuristics, MATCHPQ and MATCHPT. ADI is a small step toward interactive, practical program verification.     

Moped (a portable debugger)

Moped is a portable debugger that uses enhanced tracing facilities and backtracing to discover unusual or undesirable program behaviors. It is based upon two modules — Program Probes and Program History. Program Probes is a forward tracing utility which allows Moped to dynamically examine the execution of a program. Program History is a backtracing utility which allows Moped to study the executed section of a program. Together, Program Probes and Program History enable Moped to have more control over the behavior of a program than either one of them, and consequently to provide an easier path toward program debugging. Moped is written in Common LISP with no dependencies on details of the machine implementation. Therefore, it is easily portable to any Common LISP environment.     

Code compaction for parallel architectures

There are two principal methods used to exploit the parallelism available on a parallel machine: the program to be executed can be optimized by hand, or the program can be automatically converted to parallel machine code by a compiler. The first method usually derives parallelism at the procedure level; a parallel program is written in a high-level language and typically has various modules executing in parallel. By contrast, the compiler methodically transforms the program into parallel code using various transformations, such as code movement. The automatic conversion of a program to parallel code is called compaction or parallelization. This paper describes the evolution of a new compaction program and presents a new algorithm for determining legal code movements. A simulator of the target architecture was used to estimate the execution times of a sample suite of programs before and after compaction. The results verify that substantial advantages arise from applying this compaction technique.     

A Massively Parallel Memory-Based Story System for Psychotherapy

We describe a memory-based system for psychotherapy, Dr. Bob, built to run on the data parallel processor Thinking Machines, Inc., CM-2a Connection Machine. The system retrieves, in parallel, stories of alcohol addiction and sexual abuse which can he used by psychiatrists in working with their patients as part of their work in recovering from addictive behavior and psychological trauma. The program is written in *LISP (pronounced Star LISP), a version of LISP used in programming Connection Machines.     

基于AutoCAD2000平台的几何元素三维重建技术

介绍了在AutoCAD2000的平台上用Visual LISP语言编程实现几何元素三维重建的技巧,通过对几个主要判别原则的探讨。成功地编写了几何元素三维重建技术的实用化程序。     

Input/output facilities in LISP 1.9

LISP1.9 provides new input/output facilities, the conceptual channel and the current channel, which make program writing easier and execution faster. The channel attributes-column-setting, line number option, prompt-string, user-buffer, eol-handler, eof-handler and access rights-are useful for program writing; the channel interaction attributes-input-memo, output-memo and file I/O verification-are useful for system development. Random file I/O, array I/O, record handling, array-string conversion and Japanese character output are also provided.     

基于单片机协议转换器在动力监控系统中应用

由于在动力系统的各种类型动力设备采用不同的协议,要实现组网监控,就要进行相关的协议转换，本文主要简述了一种基于单片机实现协议转换的整体方案,并改进硬件和软件设计,提高单片机运行稳定性和数据传输的可靠性，用该方案设计的协议转换器,在实际中应用中达到预期目的。     

A practical approach to software metrics

Metrics programs that create meaningful change in software practice must start with business goals in mind. Software metrics are quantitative standards of measurement for various aspects of software projects. A well-designed metrics program will support decision making by management and enhance return on the IT investment. There are many aspects of software projects that can be measured, but not all aspects are worth measuring. Starting a new metrics program or improving a current program consists of five steps: identify business goals; select metrics; gather historical data; automate measurement procedures; and use metrics in decision making     

A portable lisp compiler

The programming language LISP is usually implemented via an interpreter, and a compiler is added later as a LISP program. However, all such production compilers known to the authors produce explicit instructions for the given computer being used. This paper describes the development of a portable LISP compiler in the sense that only Standard LISP functions are used in its definition and the output is a sequence of abstract machine codes, easily mapped to instruction sequences on current computers. The resulting code is quite efficient, demonstrating once again the maxim that most compiler optimization is largely machine independent.     

Moped (a portable debugger)

Moped is a portable debugger that uses enhanced tracing facilities and backtracing to discover unusual or undesirable program behaviors. It is based upon two modules — Program Probes and Program History. Program Probes is a forward tracing utility which allows Moped to dynamically examine the execution of a program. Program History is a backtracing utility which allows Moped to study the executed section of a program. Together, Program Probes and Program History enable Moped to have more control over the behavior of a program than either one of them, and consequently to provide an easier path toward program debugging. Moped is written in Common LISP with no dependencies on details of the machine implementation. Therefore, it is easily portable to any Common LISP environment.This work supported in part by Hewlett-Packard Company, the National Science foundation Under Grant Number MCS81-21750 and the Defense Advanced Research Projects Agency under contract number DAAK11-84-K-0017.     

Declarative planning in procedural agent architectures

Practical agent languages and their corresponding architectures have often relied on a static plan library with more or less direct trigger-response activation mechanisms as a source for agent behaviours for the sake of runtime efficiency. Although efficient, such a language design choice severely limits an agent’s ability to reason about its goals and adapt to unforeseen circumstances after being deployed. This effectively delegates the task of planning to the designers themselves, who must design plan libraries able to cope with every foreseeable situation an agent might find itself in by designing plans to deal with any contingency. In this paper we develop a formal conversion process from traditional BDI agent languages into declarative planning. Using this conversion process, we show how to integrate domain independent planning algorithms into the BDI interpreter, allowing a designer to program an agent not only through the trigger-response mechanism used in traditional languages, but also in terms of declarative goals. Our contribution here is twofold: firstly we increase an agent’s ability to cope with unforeseen situations and secondly we unburden an agent designer from having to define multiple plan combinations that could be easily generated by a planner.     

Design and implementation of the WIPI-to-Android automatic mobile game converter for the contents compatibility in the heterogeneous mobile OS

Given that mobile communication companies choose different mobile platforms, game developers must create content designed specifically for each platform or use a conversion process to provide game content to consumers. In this paper, to resolve this problem, the WIPI-to-Android automatic mobile game converter was designed to automatically translate game contents from the WIPI (Wireless Internet Platform for Interoperability) for feature phones to the Android platform for smart phones. Through the WIPI-to-Android converter, resources such as images and sounds can be converted, APIs can be converted using a platform mapping engine, and source code can be translated using the source translator. These and all other content conversion functions were examined. Test results indicate that the graphics, image output, sound output, and other functions of converted Android games were equivalent to those of the WIPI games before conversion. Furthermore, most converted Android game content responded more quickly than the WIPI game content.     

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.