ppxscal/embedding_network huggingface dataset:
Legal data modeling: The prohibited transaction exemption analyst
Authors: K. Bellairs
Venue: Proceedings of the 1st international conference on Artificial intelligence and law (1987)

This paper addresses issues in the design of legal expert systems. The emphasis is on the nature of the underlying knowledge that is incorporated in the knowledge base of a legal expert system. Examples of different approaches are discussed. The &ldquo;legal data modeling&rdquo; approach, used by the author in the construction of an expert system, is described. Legal data modeling emphasizes the construction of a conceptual model of situations in which legal problem solving occurs.
The PSG system: from formal language definitions to interactive programming environments
Authors: Rolf Bahlke, Gregor Snelting
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1986)

The PSG programming system generator developed at the Technical University of Darmstadt produces interactive, language-specific programming environments from formal language definitions. All language-dependent parts of the environment are generated from an entirely nonprocedural specification of the language's syntax, context conditions, and dynamic semantics. The generated environment consists of a language-based editor, supporting systematic program development by named program fragments, an interpreter, and a fragment library system. The major component of the environment is a full-screen editor, which allows both structure and text editing. In structure mode the editor guarantees prevention of both syntactic and semantic errors, whereas in textual mode it guarantees their immediate recognition. PSG editors employ a novel algorithm for incremental semantic analysis which is based on unification. The algorithm will immediately detect semantic errors even in incomplete program fragments. The dynamic semantics of the language are defined in denotational style using a functional language based on the lambda calculus. Program fragments are compiled to terms of the functional language which are executed by an interpreter. The PSG generator has been used to produce environments for Pascal, ALGOL 60, MODULA-2, and the formal language definition language itself.
The development of computer oriented small businesses in a university sponsored incubator: an overview and case study
Authors: R. R. Goforth, R. M. Crisp,  Jr., G. B. Seiff
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

GENESIS is a business incubator program of the University of Arkansas with an ultimate mission of providing jobs for the citizens of Arkansas. Funded by the Arkansas Science and Technology Authority (ASTA), this program provides business and technical assistance for technology based start-up companies. Energy Techniques, Inc., is one of the three original companies in the program. Using custom software and commercially available equipment, Energy Techniques provides systems for centralized energy management of dispersed buildings. Structured University support is provided through such agencies as the Entrepreneurial Services Center and the Center for Technology Transfer. Specialized expertise is made available through consulting arrangements with the University teaching and research staff. Both opportunities and potential problems for a university hosted incubator are noted.
Two FORTRAN packages for assessing initial value methods
Authors: W. H. Enright, J. D. Pryce
Venue: ACM Transactions on Mathematical Software (TOMS) (1987)

We present a discussion and description of a collection of FORTRAN routines designed to aid in the assessment of initial value methods for ordinary differential equations. Although the overall design characteristics are similar to those of earlier testing packages [2,6] that were used for the comparison of methods [5,7], the details and objectives of the current collection are quite different. Our principal objective is the development of testing tools that can be used to assess the efficiency and reliability of a standard numerical method without requiring significant modifications to the method and without the tools themselves affecting the performance of the method.
A Synthesis of Software Science Measures and the Cyclomatic Number
Authors: Bina Ramamurthy, Austin Melton
Venue: IEEE Transactions on Software Engineering (1988)

A solution is obtained to the problem of defining a software measure or a family of measures which simultaneously detect those aspects of software complexity that are detected by the software science measures and the cyclomatic number. The authors present a family of measures, called weighted measures that is built on the software science measures by adding weights to certain operators and operands; the size of the weights is determined by a theorem which relates nesting levels and the cyclomatic number. Thus, by construction the weighted measures synthesize the software science measures and the cyclomatic number. Further, by applying the weighted measures, the software science measures, and the cyclomatic number to sample programs, it is shown that the weighted measures also synthesize in practice the software science measures and the cyclomatic number.
Multi-process structuring of user interface software
Authors: K A Lantz
Venue: ACM SIGGRAPH Computer Graphics (1987)

Many contemporary user interface management systems suffer from the lack of adequate operating system support for multi-process structuring. They either adopt a single-process server approach, resulting in monolithic code, or are implemented as run-time libraries, resulting in a high degree of redundancy and complex synchronization problems. This paper, on the other hand, describes a methodology that takes advantage of lightweight processes and fast interprocess communication to structure user interface software as multiple cooperating processes. It demonstrates that such an approach can lead to exceptional flexibility -- with respect to the addition of new functionality, in particular -- without sacrificing performance.
A New Security Testing Method and Its Application to the Secure Xenix Kernel
Authors: Virgil D. Gligor, C. S. Chandersekaran, Wen-Der Jiang, Abhai Johri, Gary L. Luckenbaugh, L. Edward Reich
Venue: IEEE Transactions on Software Engineering (1987)

A new security testing method is proposed that combines the advantages of both traditional "black box" (monolithic functional) testing and "white box" (functional-synthesis-based) testing. The new method allows significant coverage both for security model-based tests and for individual kernel-call tests. It eliminates redundant kernel test cases 1) by using a variant of control synthesis graphs, 2) by analyzing dependencies between descriptive kernel-call specifications, and 3) by exploiting access check separability. A higher degree of test assurance is achieved than that of other security testing methods because the new method helps eliminate cyclic dependencies among test programs for different kernel calls. The application of this method to the testing of the Secure Xenix kernel is illustrated.
Distribution of software engineering concepts beyond the software engineering course
Authors: James Calhoun
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

The importance of the role of documentation in the development and maintenance of software is not in dispute among computer professionals. Within the profession, software has come to mean more than just the source or object code which is produced. A modern definition of software includes documents as a vital component. The largest part of such documentation is external to the program and records the history of the project. Included could be project plans, requirements specification, preliminary detailed code design, user-directed manuals and maintenance journals.All too often the computer science curriculum, whether by design or default, limits student experience with external documentation to specialized courses such as software engineering. While the documentation experience provided by these courses may prove valuable, its quality may be limited by the student's attitude. If the student's previous experience has been limited to internal documentation, there is a good chance that he has come to view documentation as an add-on, something to be completed after the project is really finished. It is difficult to alter this mind-set.Identification of a solution to this problem may require not only a reevaluation of the documentation requirements for student software projects but an examination of the availability of programming languages and design tools which support the documentation effort. This paper reports the development of several design tools which are intended for student use in the preparation of preliminary project documentation. Special among these is an interactive graphics editor to be used to assist in the design, documentation and implementation of programs.
Direct parallelization of call statements
Authors: Rémi Triolet, Francois Irigoin, Paul Feautrier
Venue: ACM SIGPLAN Notices (1986)

Asynchronous CALL statements are necessary in order to use more than one processor in current multiprocessors. Detecting CALL statements that may be executed in parallel is one way to fill this need. This approach requires accurate approximations of called procedure effects. This is achieved by using new objects called Region and Execution Context. An algorithm to find asynchronous CALL statements is given. It involves a new dependence test to compute data dependence graphs, which provides better results than previous ones even when no CALL statements are involved. This method has been implemented in Parafrase and preliminary results are encouraging.
Design Stability Measures for Software Maintenance
Authors: Stephen S. Yau, James S. Collofello
Venue: IEEE Transactions on Software Engineering (1985)

The high cost of software during its life cycle can be attributer largely to software maintenance activities, and a major portion of these activities is to deal with the modifications of the software. In this paper, design stability measures which indicate the potential ripple effect characteristics due to modifications of the program at the design level are presented. These measures can be generated at any point in the design phase of the software life cycle which enables early maintainability feedback to the software developers. The validation of these measures and future research efforts involving the development of a user-oriented maintainability measure, which incorporates the design stability measures as well as other design measures, are discussed.
A O(t3+ |E| ) Fault Identification Algorithm for Diagnosable Systems
Authors: Gregory F. Sullivan
Venue: IEEE Transactions on Computers (1988)

Systems composed of many processing units can use these units to help perform self-diagnosis. An algorithm is presented that performs this type of diagnosis for the system-level fault model. The time complexity of the algorithm is O(t³+ |E|), where |E| is the number of tests and t is the number of allowed faults. When t is small relative to the total number of system components n, this is the tightest known time bound; when t is O(n/sup 5/6/) this is the best bound.
Design and evaluation of parallel pipelined join algorithms
Authors: James P. Richardson, Hongjun Lu, Krishna Mikkilineni
Venue: ACM SIGMOD Record (1987)

The join operation is the most costly operation in relational database management systems. Distributed and parallel processing can effectively speed up the join operation. In this paper, we describe a number of highly parallel and pipelined multiprocessor join algorithms using sort-merge and hashing techniques. Among them, two algorithms are parallel and pipelined versions of traditional sort-merge join methods, two algorithms use both hashing and sort-merge techniques, and another two are variations of the hybrid hash join algorithms. The performance of those algorithms is evaluated analytically against a generic database machine architecture. The methodology used in the design and evaluation of these algorithms is also discussed. The results of the analysis indicate that using a hashing technique to partition the source relations can dramatically reduce the elapsed time hash-based algorithms outperform sort-merge algorithms in almost all cases because of their high parallelism. Hash-based sort-merge and hybrid hash methods provide similar performance in most cases. With large source relations, the algorithms which replicate the smaller relation usually give better elapsed time. Sharing memory among processors also improves performance somewhat.
Voice transmission in a priority CSMA/AC LAN: an efficient protocol using hybrid switching
Authors: J van da Lagemaat, J M A Daemen, I G Niemegeers
Venue: ACM SIGCOMM Computer Communication Review (1986)

The integration of voice and data transmission on a CSMA/CD LAN with message priority and deterministic collision resolution is studied. As a result an efficient Stream Traffic Protocol using hybrid switching and implicit token passing is designed. The performance of the protocol both for voice and data is analysed using a discrete event simulation model. The protocol increases the system capacity for voice while the strict real-time constraints for its transmission are still met. It supports a number of subscribers comparable with the equivalent to the capacity of a small PABX, with a good performance for data. The work is part of an overall project of an integrated services LAN offering ISDN S-interfaces.
Factors of success for end-user computing
Authors: Suzanne Rivard, Sid L. Huff
Venue: Communications of the ACM (1988)

A two-phase study concerned with the factors of success associated with the development of computer applications by end users was conducted in 10 large organizations. During the first phase, in-depth interviews were used to refine a preliminary model of the factors of success for user development of computer applications (UDA). In the second phase, a questionnaire was administered to 272 end users experienced in developing applications. Statistical tests of the relationships in the model indicated that all but one of the derived hypotheses were substantiated. The result of this study is a field-verified model of the factors of success of UDA that provides a basis for implementation of UDA practices and policies in organizations, as well as for further research in end-user computing.
Finding Lowest Common Ancestors in Parallel
Authors: Yung H. Tsin
Venue: IEEE Transactions on Computers (1986)

Two parallel algorithms for finding the lowest common ancestors of a set of vertex pairs Q (the query set) in a directed tree are presented. With all the overheads taken into account, these algorithms take O((n + QI) P log2 n) and O(n2/p + log2n) time, respectively, with p(> 0) processors (n is the size of the tree). These results are better than the best known result in that the first achieves th
Efficient implementation of the OSI transport protocol checksum algorithm using 8/16-bit arithmetic
Authors: A. Cockburn
Venue: ACM SIGCOMM Computer Communication Review (1987)

The checksum algorithm recommended in the OSI transport-protocol specfications is an arithemetic checksum algorithm which makes heavy use of base-255 addition. In this technical note, an efficient implementation of the recommended checksum algorithm is derived, using 8-bit unsigned addition as the base for an inexpensive modulo-255 addition.
Implementing separate compilations in Pascal
Authors: G. Nani
Venue: ACM SIGPLAN Notices (1987)

PIC (Pascal Interface Controller) is a tool for the development of large, modular software systems in Pascal. The new kind of modularity, implemented by PIC, is analyzed in the paper. Two different versions of PIC have been developed, to interface with Pascal compilers providing different support to program decomposition into compilation units.
Real-time manipulation of texture-mapped surfaces
Authors: Masaaki Oka, Kyoya Tsutsui, Akio Ohba, Yoshitaka Kurauchi, Takashi Tago
Venue: ACM SIGGRAPH Computer Graphics (1987)

A system for real-time texture mapping was constructed, Here, "real-time" means that the system reacts to changes in parameter values which define the shape of surfaces and the viewing point that are given by its operator 30 times per second. This real-time processing enables interactive manipulation of texture-mapped free-form surfaces and various application software has been developed taking advantage of this ability. The system owes its performance to a new algorithm for texture mapping which is based on a newly proposed approximation scheme of mapping functions. In this scheme, a mapping function from the texture plane into the output screen is approximated by a linear function on each of the small regions which form the texture plane altogether. The algorithm is very simple and applicable to any smooth surface. It is especially efficient when implemented by a special-purpose hardware.
Implementing a user interface as a system of attributes
Authors: Roger King, Scott Hudson
Venue: Proceedings of the second ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments (1987)

In a syntax directed editor, or programming environment using a graphical user interface, how do you keep the display and other aspects of the user interface up to date with changes to the underlying abstract syntax tree? This paper addresses this question by showing how existing incremental attribute evaluation techniques can be combined with graphical techniques to allow a user interface to be managed automatically as a system of attributes. In a nutshell, presentations can be described and implemented by small pseudocode fragments for a special purpose graphics pseudomachine. The control and composition of these code fragments, and hence the presentations which they implement, is done as an attribute computation.
Human-computer communication meets software engineering
Authors: C. Rathke
Venue: Proceedings of the 9th international conference on Software Engineering (1987)

A contemporary software engineering problem is to adapt an existing piece of software to a new interface technology.We describe the process of integrating a software engineering tool with a window-based direct manipulation interface. Four stages of this process are described - from a simple integration to a fully integrated system in which it becomes hard to separate properties of the tool from those of the interface.We take advantage of WLISP, an object-oriented, knowledge-based user interface construction kit that contains a large number of tools and intelligent support systems. The object-oriented architecture of WLISP is well suited for making use of existing interface components and tailoring them to the specific needs of the application. This is illustrated by describing the implementation of two of the four integration stages in some detail. Thereby we show benefits and problems of separating the interface from the application system.
Software metrics using deviation value
Authors: Y. Miyazaki, N. Murakami
Venue: Proceedings of the 9th international conference on Software Engineering (1987)

The Deviation-value (D-value) is a new measure for software data involved during software development. The D-value provides an alternative to software metrics based upon &ldquo;per number of lines of code&rdquo; such as error rate (number of errors per thousand lines of code) and documentation rate (number of pages of module design documentation per thousand lines of code). Using D-value, the data of software modules are much more fairly evaluated than these conventional metrics.This paper presents the derivation of the D-value using the theoretical background of a control chart called u chart and weighted regression analysis. The advantage of using the D-value rather than metrics based upon &ldquo;per number of lines of code&rdquo; is demonstrated through an analysis of the data of four projects. The D-value is used to find the data items which actually relate to software quality, and we find that the quality of each module measured by D-value becomes better as the documentation rate D-value increases. Finally, using the theory behind the D-value, a new software acceptance guideline is discussed.
An Alternative to Scan Design Methods for Sequential Machines
Authors: Kewal K. Saluja, Ramaswami Dandapani
Venue: IEEE Transactions on Computers (1986)

The problem of testing sequential machines using a checking experiment is investigated. An algorithm is given to augment sequential machines by adding extra input(s) to make them testable. We also present a circuit modification method, similar to scan methods, such that the augmented machine can be tested by the checking experiment. A justification of our method for a VLSI environment is given by determining the overheads.
Techniques for extracting statistical data from free-form text using APL
Authors: L. Owen Hill, David A. Zein
Venue: ACM SIGAPL APL Quote Quad (1987)

A family of methods has been developed for processing free-form text files using APL. We assume that a file has an arbitrary structure and has regions of statistical and numerical data embedded in it. The data in the file are processed to extract the following information: 1. the embedded statistical and numeric regions, 2. titles, keys (legends), and tic-mark identifiers, associated with each region, and 3. dates and other pertinent information. Once these data are extracted, bar, line, pie charts or a combination of those are plotted. An APL program which is automatically loaded and invoked performs these tasks. The program has been tested on hundreds of files with different structures. Some of these files have multiple statistical regions.
A generator for language-specific debugging systems
Authors: R. Bahlke, B. Moritz, G. Snelting
Venue: ACM SIGPLAN Notices (1987)

We present a system which generates interactive high-level debugging systems from formal language definitions. The language definer has to specify a denotational semantics augmented with a formal description of the language specific debugging facilities. The generated debugger offers the traditional features such as tracing programs, setting breakpoints, displaying variables etc; interaction with the user is always on language level rather than on machine level. The concept has been implemented as part of the PSG-Programming System Generator, and has successfully been used to generate debuggers for Pascal and Modula-2. The core of the implementation consists of an interpreter for a functional language, which has been extended with the language-independent mechanisms needed in order to allow interaction with the user during program execution.
Using an expert system to improve microcomputer consulting
Authors: Janice I. Bucker, Paul L. Juell
Venue: Proceedings of the 15th annual ACM SIGUCCS conference on User Services (1987)

An expert system has been developed to assist faculty, staff, and students at North Dakota State University (NDSU) in making microcomputer purchasing decisions. Expert systems have been utilized in increasing numbers in manufacturing, medicine, and business (Waterman, 1986; Fisher, 1987) as a means to provide consistent, accurate information, and make the knowledge of experts available to more people and in a wider range of applications (Voelker and Ratica, 1986). It seems natural then, that expert systems should find a place in academic user services where it is necessary to provide information to a large number of people very often with a limited number of consultants.