Common Programming Languages Research Articles

Distributed shared-memory implementation for multitransputer systems

A new method for the implementation of distributed shared memory on multitransputer systems is presented. The method is based on an extension of the common parallel programming language occam2, allowing the use of constructs such as virtual channels, global semaphores, and shared variables (with strong coherence). The allocation of the shared variables is done at compile-time on any of the available transputer nodes. Semaphores allow explicit process synchronization, while virtual channels facilitate the programmer's task, by providing an abstract view of process communication, regardless of the particular network topology.

A weight-learning algorithm for fuzzy production systems with weighting coefficients

This paper presents a method for debugging knowledge bases in the form of fuzzy production systems with weighting coefficients, i.e. sets of fuzzy rules with associated weighting coefficients. The method is based on a weight-learning algorithm for finding the right weighting coefficients of fuzzy rules with respect to some goal premise-conclusion pair of fuzzy sets. A necessary and sufficient condition for convergence of the weight-learning algorithm is proved. A program implementation of the weight-learning algorithm in golden common lisp programming language for an IBM PC AT microcomputer and compatible ones is presented. The results of computer experiments are reported and analysed.

Unity Doesn't Imply Unification or Overcoming Heterogeneity Problems in Distributed Software Engineering Environments

Unity Doesn't Imply Unification or Overcoming Heterogeneity Problems in Distributed Software Engineering Environments

A Rule-Based Expert System for Automatic Control Rod Pattern Generation for Boiling Water Reactors

This paper reports on an expert system for generating control rod patterns that has been developed. The knowledge is transformed into IF-THEN rules. The inference engine uses the Rete pattern matching algorithm to match facts, and rule premises and conflict resolution strategies to make the system function intelligently. A forward-chaining mechanism is adopted in the inference engine. The system is implemented in the Common Lisp programming language. The three-dimensional core simulation model performs the core status and burnup calculations. The system is successfully demonstrated by generating control rod programming for the 2894-MW (thermal) Kuosheng nuclear power plant in Taiwan. The computing time is tremendously reduced compared to programs using mathematical methods.

Lists processing for artificial intelligence applications

Lisp is one of the most common programming languages for expert systems implementation. However, many problems exist in the Lisp language which affect Lisp programs performance. An existing expert system shell with fuzzy concepts in Lisp is studies to identify the bottlenecks of such systems. A hardware assisted architecture is proposed to solve these problems. This paper presents these problems and suggests a hardware assisted approach. The proposed architecture emphasizes on the list data structure and hash-table handling. The evaluation of the performance of the architecture is also given.

A Knowledge-Based System for Optimization of Fuel Reload Configurations

The authors discuss a knowledge-based production system developed for generating optimal fuel reload configurations. The system was based on a heuristic search method and implemented in Common Lisp programming language. The knowledge base embodied the reactor physics, reactor operations, and a general approach to fuel management strategy. The data base included a description of the physical system involved, i.e., the core geometry and fuel storage. The fifth cycle of the Three Mile Island Unit 1 pressurized water reactor was chosen as a test case. Application of the system to the test case revealed a self-learning process by which a relatively large number of near-optimal configurations were discovered. Several selected solutions were subjected to detailed analysis and demonstrated excellent performance. To summarize, applicability of the proposed heuristic search method in the domain of nuclear fuel management was proved unequivocally.

Mkscan—An interactive scanner generator

AbstractMkscan is a tool for generating and editing scanners. It has been designed with ease of use in mind. The tol is interactive and uses a full screen interface. No attempt is made to provide an all‐purpose tool that can generate a recognizer for any regular language. Instead, mkscan has been tailored to suit the lexical structure of common programming languages and command languages. Using mkscan, a scanner for Pascal can be created in under ten minutes–including the time taken to type the list of keywords.

Software Science Applied to APL

Previous attempts to apply Halstead's software metrics to APL have led to inconsistent and counter-intuitive results. This work is a further investigation into the application of software metrics to APL to try to resolve some of the inconsistency. The effect of variations in the counting rules on values calculated for the software metrics was studied. These rules were used to analyze a set of programs from a previous study. In addition, a large number of APL programs from a university environment were analyzed. Evidence is presented that verifies that APL has a higher language level than any other common programming language previously studied. Counting monadic and dyadic uses of the same APL symbol as an instance of a different operator was found to have a significant effect on the language level calculated for APL. However, decomposing derived APL functions into separate operators did not seem to have a significant effect on language level.

An environment for logic programming

We describe a programming environment for Prolog, a common logic programming language. The services offered by our system assist a Prolog user in the tasks of composing, editing, and storing logic (rule-based) programs, as well as in the control of their execution for debugging purposes. In order to facilitate effective debugging of Prolog programs, we propose a new model of computation that can handle both pure Prolog and impure (side-effect causing) Prolog operations quite gracefully. This model employs two stacks representing the state of a computation with respect to the two major activities of Prolog execution: recursion and backtracking. This representation, in addition to being quite clear and intuitive, is easy to display on a terminal's screen and can be further processed. We also describe a Prolog oriented editor with which the user may easily create and update Prolog source programs and, further, inspect states of computation as generated by the debugger.

Common programming language ambiguity

When most people think of portable programs they think of programs that can be compiled by different compilers (with few, if any, changes required in the source code). It is an unwritten assumption that all of these compilers accept (to a reasonable degree) the same language.In this paper we shall demonstrate that this commonly required similarity can be relaxed considerably under certain circumstances. This is accomplished by introducing an unusual new technique for writing portable programs.

Use of a tabletop computer in controlled substances distribution

The use of a tabletop computer for controlled substances distribution is described. The self-contained system uses programs stored on discs to maintain records for floor stock, individual patient orders, and ambulatory patient prescriptions. Three reports are generated daily: (1) a listing of all floor supplies issued on the current date, (2) a listing of all individual patient supply transactions for the current date, and (3) an alphabetical listing of the inventory for controlled substances, including an alert system to identify any item that has fallen below a preselected minimum stock level. The tabletop computer allowed the pharmacy to take advantage of the accuracy and speed of electronic data processing at its own pace, independent of the hospital's main computer system. Because the tabletop computer and the main system both use a common programming language, any programs developed on the tabletop computer can be converted to the main system.

Another experiment with teaching of programming languages

The key issue in successful teaching is that of keeping the interest of students alive. In a first course on computer programming, this can be achieved by presenting interesting problems of reasonable complexity early in the course. This is often a difficult task, as most of the common programming languages used for instruction are intangible and therefore cumbersome to master before any serious programming may start.Here a simple and tangible programmable machine is introduced. It is shown that important programming concepts can be defined and exercised in terms of possible operations on this machine. It is also shown that a seemingly difficult problem can be solved by novice programmers within the first few sessions of an introductory course.

Pearl at the age of five: Case study of development and application of a common high order realtime programming language

The Programming language PEARL for industrial process automation has been developed since 1969. After extensive studies its final definition was frozen in 1976. Since then considerable experience has been gained with some 25 implementations and 200 applications. With PEARL at the age of three, these experiences are offered as a case study in this paper. The paper starts with a characterization of PEARL by indicating the requirements for such a tool, by classifying it with respect to other language types and by pleading for embedded realtime features. As PEARL has been submitted to ISO for international standardization, the question of how it meets the requirements set up by ISO is more thoroughly answered in Appendix A. The report of experience is given separately for implementation, application, and standardization with as much quantitative results as possible, including compiler behaviour, application areas, and economical benefit. For readers not yet familiar with PEARL a tutorial introduction by means of a simple but completely programmed control problem is given in Appendix B.

Definition, Implementation, And Assessment Of Natal-74-An Author Language For Computeraided Learning

AbstractExchange of computer-aided learning (CAL) course material has been severely restricted by the lack of a commonly accepted or standard programming language for the representation of these materials. It was with this problem in mind that the National Research Council’s Associate Committee on Instructional Technology initiated work towards the development of a common programming language for CAL. In 1972, the Committee published a functional specification for a CAL programming language which represented a consensus of opinion of a group of active CAL users. This document was subsequently used as the basis of a contract for the development of a detailed language specification which was delivered in 1974.The language, NATAL-74, has since been implemented on a DECsystem-10 at the National Research Council and testing is underway. The paper discusses the rationale for the project; techniques used in the definition of the language, both at the functional level and the detailed level; the procedures used a...

Efficient LL(1) error correction and recovery using only insertions

An LL(1)-based error-corrector which operates by insertion-only is studied. The corrector is able to correct and parse any input string. It is efficient (linear in space and time requirements) and chooses least-cost insertions (as defined by the user) in correcting syntax errors. Moreover, the error-corrector can be generated automatically from the grammar and a table of terminal symbol insertion costs. This method is also very well suited for use as an automatic error-recovery technique in LL(1) parsers. The class of LL(1) grammars correctable by this method contains (with minor modifications) grammars used to specify most common programming languages. Preliminary results suggest that this method can be used to advantage in LL(1)-driven compilers.

The DoD common high order programming language effort (DoD-1)

The DoD common high order programming language effort (DoD-1)

Language design for the Ironman requirement

The Tartan language was designed as an experiment to see whether the Ironman requirement for a common high-order programming language could be satisfied by an extremely simple language. The result, Tartan substantially meets the Ironman requirement. We believe it is substantially simpler than the four designs that were done in the first phase of the DOD-1 effort. The language definition appears in a companion report; this report provides a more expository discussion of some of the language's features, some examples of its use, and a discussion of some facilities that could enhance the basic design at relatively little cost.

DoD's Common Programming Language Effort

DoD's common programming language effort is aimed at reducing the development and maintenance cost and improving the quality of software for embedded computer systems. Here is a brief review of the background, scope, goals, and methods of that effort.

An Interactive Computer Graphics Language for the Design and Simulation of Digital Systems

Many computer hardware description languages have been introduced to describe and model digital networks at the register transfer level.1-3Most CHDL's, however, like common programming languages, are text oriented and employ textual statements in the specification of a digital system. The process of converting a word statement problem into a description written in a design language is often tedious, especially when the design is complex. Many designers overcome this difficulty by drawing register layouts and control sequence or state diagrams for a design before hand-translating them into a specification in an appropriate design language. With the reduction in the costs of on-line computing and graphic terminals, this approach can be used early in the computer-aided-design cycle. This has in fact been accomplished at the University of Missouri-Rolla, where a graphic language called FLOWWARE has been developed to allow digital networks to be specified pictorially.

Programming-in-the large versus programming-in-the-small

We distinguish the activity of writing large programs from that of writing small ones. By large programs we mean systems consisting of many small programs (modules), possibly written by different people. We need languages for programming-in-the-small, i.e. languages not unlike the common programming languages of today, for writing modules. We also need a “module interconnection language” for knitting those modules together into an integrated whole and for providing an overview that formally records the intent of the programmer(s) and that can be checked for consistency by a compiler. We explore the software reliability aspects of such an interconnection language. Emphasis is placed on facilities for information hiding and for defining layers of virtual machines.