Search

This article focuses on ways to produce normalized representations in ontology from a wide range of different ways of expressing the same idea and describes a particular mechanism for normalizing frequently occurring comparative constructions. To create useful representations of natural language text, first obtain a compact representation of the syntactic and semantic structures for each sentence, using the Xerox Linguistic Environment, a deep parser based on Lexical Functional Grammar theory. Reasoning systems that receive well-specified input can utilize carefully constrained ontologies that capture exactly the set of concepts necessary for the task at hand. Matching based on midlevel concepts and role comparisons is one mechanism for assessing similarity, but others need to handle some common linguistic constructions. Two design criteria have been discussed for ontologies to support the task of finding similarities and redundancies in an ontology to support tasks such as identification of the appropriate level of abstraction in representation, and the normalization of dimensions for comparatives. In general, it is balancing adequacy in expressiveness against complexity in similarity reasoning. As of February 2002, the system normalizes the dimensional comparisons that occur in the test set of 15 similar pairs of documents and exploits mid-level categories to make similarity assessments. It is expected that these criteria, along with others that will emerge as the research progresses, will form the basis for defining a powerful yet tractable ontology for large-scale knowledge extraction from documents.

The article examines the knowledge-based expert systems that achieve expert level performance using explicit representations of knowledge. It tries to capture some of the relevant experience with systems that clearly fit the used model, rather than trying to define precisely what is or is not an expert system. The emphasis here has been on the explicit representation of knowledge in a system, rather than system performance. Therefore, no matter how clever a C-Compiler is, it will not be called an expert system if it were not built in this style. Expert systems need not be rule based or contain a theorem prover and can be built in any language, although it is easier where language and environment readily support the conversion of user's intent into programs. Since building an expert system is a large software project, standard software engineering analyses are useful in understanding the scope and nature of the job. One can build expert systems for appropriate problems provided experts are available who are articulate, patient and committed to a project for at least the initial phases.

This paper describes a new way of solving the storage reclamation problem for a system such as Lisp that allocates storage automatically from a heap, and does not require the programmer to give any indication that particular items are no longer useful or accessible. A reference count scheme for reclaiming non-self-referential structures, and a linearizing, compacting, copying scheme to reorganize all storage at the users discretion are proposed. The algorithms are designed to work well in systems which use multiple levels of storage, and large virtual address space. They depend on the fact that most cells are referenced exactly once, and that reference counts need only be accurate when storage is about to be reclaimed. A transaction file stores changes to reference counts, and a multiple reference table stores the count for items which are referenced more than once. [ABSTRACT FROM AUTHOR]

Many control and access environment structures require that storage for a procedure activation exist at times when control is not nested within the procedure activated. This is straightforward to implement by dynamic storage allocation with linked blocks for each activation, but rather expensive in both time and space. This paper presents an implementation technique using a single stack to hold procedure activation storage which allows retention of that storage for durations not necessarily tied to control flow. The technique has the property that, in the simple case, it runs identically to the usual automatic stack allocation and deallocation procedure. Applications of this technique to multitasking, coroutines, backtracking, label-valued variables, and functional arguments are discussed. In the initial model, a single real processor is assumed, and the implementation assumes multiple-processes coordinate by passing control explicitly to one another. A multiprocessor implementation requires only a few changes to the basic technique, as described. [ABSTRACT FROM AUTHOR]

List processing systems should be designed to facilitate production of large programs to manipulate large complex symbolic data stores. This paper presents an overview of a number of system features which the author feels are important to improve the productivity of programmers working in such domains. A systems view is taken, rather than focusing just on language features, since algorithms must be not only coded in a language form, but debugged, modified, made efficient, and run on data Because of this general framework, the requirements specified are applicable to the design of advanced programming systems for a wide range of applications Three aspects of programming systems are highlighted good interactive facilities, programmable control structures, and sophisticated data communication mechanisms Interactive features are described to facilitate program composition, entry, testing, debugging, editing, optimization, and packaging. Implementation of a generalized environment structure model specified would allow programming of various control regimes including multi processes, coroutines and backtracking. Alternative methods of procedure invocation required include invocation by pattern and by monitoring condition. The need for extended data forms, storage management, and extensibility are stressed, as is the duality of data retrieval and function evaluation. Syntax directed input and output of data would facilitate use of complex data stores. [ABSTRACT FROM AUTHOR]

Describes how the TENEX, a paged time sharing system implemented on a DEC PDP-10 augmented by special paging hardware, specifies a set of goals. Effect of time operational requirement on the implementation of the system; Constraints imposed by the scale of the system and available resources on the implementation of the system.

Explores the design and implementation of a computer-based system to alleviate the problem of rule evaluation for the linguist in the area of phonology. Phonemes; Effect of applying rule to the data; Translation of linguistic rules to rules in a format-directed list processor; Online applications.

In an ideal list-processing system there would be enough core memory to contain all the data and programs. Described in this paper are a number of techniques that have been used to build a LISP system utilizing a drum for its principal storage medium, with a surprisingly low time penalty for use of this slow storage device. The techniques include careful segmentation of system programs, allocation of virtual memory to allow address arithmetic for type determination, and a special algorithm for building reasonably linearized lists. A scheme for binding variables is described which is good in this environment and allows for complete compatibility between compiled and interpreted programs with no special declarations. [ABSTRACT FROM AUTHOR]

Discusses the hash linking process involved in hash searching, which is used in the insertion and retrieval of data records. Description of the hash search; Non-obvious applications of the technique.

The problem of the use of two levels of storage for programs is explored in the context of a LISP system which uses core memory as a buffer for a large virtual memory stored on a drum. Details of timing are given for one particular problem. [ABSTRACT FROM AUTHOR]

Focuses on the Common LISP Object System (CLOS). Incremental definition of operations; Polymorphic operators of the language; Pattern-directed invocation tradition; Object-based programming tradition; Dimensions of partitioned operations.

The article presents information on a project that is studying aspects related to computer support of collaborative problem solving in face-to-face meetings. As part of the project an experimental meeting room known as the Colab has been set up at the company Xerox PARC with the objective to build computer tools to make meetings more effective. The project is designed for small working groups using personal computers connected over a local-area network. The Colab project is trying to understand why collaborative problem solving is organized as it is, the relationship of that organization to existing technology, and the trade-offs involved in displacing old practices with new technology.