Application Of Language Research Articles

An alternative computer architecture course

Most computer architecture courses are geared toward the classical von Neumann style of computer architectures, mentioning only in passing other models such as data flow computation. This is unfortunate, due to the high degree of parallelism possible using data flow. We present an alternative course, designed as an elective in computer architecture for upper level undergraduate or graduate students, that presents a side-by-side comparison of von Neumann and data flow architectures.Our teaching environment is based on Simple Arithmetic SISAL (SAS), a subset of the applicative programming language SISAL, which we designed for both teaching about and research into data flow architectures. SAS runs in a highly integrated environment, allowing students to implement their program on a von Neumann architecture, then observe its execution through a data flow simulator. The environment runs on a standard IBM-style personal computer, providing a cost-effective platform for presenting the course.

Software standardization integrating industrial automation systems

In order to achieve the maximum level of integration, it is necessary to develop appropriate standards for both software and communication systems. As far as the latter are concerned, the work of the international standardization organizations has already given results which will soon be used by manufacturers, vendors and users of industrial automation systems. Of great interest, however, in the industrial environment is the recent setting up of standardization activity in various sectors linked to the development of software for industrial automation systems. In this paper, on the basis of the work carried out by ISO TC184, the authors anlyze the current state of development of standards for software to be used in industrial environments, and discuss foreseeable future orientations. In particular, the following standards are outlined: step (STandard for the Exchange of Product model data), which deals with a computer-interpretable representation of product data independent of any particular computer system; maple (Manufacturing Application Programming Language Environment), which is a structured set of tools needed for integration of different application programs in an industrial environment; icr (Intermediate Code for Robots) and plr (Programming Language for Robots), which are part of a robot system programming environment.

Is continuation-passing useful for data flow analysis?

The widespread use of the continuation-passing style (CPS) transformation in compilers, optimizers, abstract interpreters, and partial evaluators reflects a common belief that the transformation has a positive effect on the analysis of programs. Investigations by Nielson [13] and Burn/Filho [5,6] support, to some degree, this belief with theoretical results. However, they do not pinpoint the source of increased abstract information and do not explain the observation of many people that continuation-passing confuses some conventional data flow analyses. To study the impact of the CPS transformation on program analysis, we derive three canonical data flow analyzers for the core of an applicative higher-order programming language. The first analyzer is based on a direct semantics of the language, the second on a continuation-semantics of the language, and the last on the direct semantics of CPS terms. All analyzers compute the control flow graph of the source program and hence our results apply to a large class of data flow analyses. A comparison of the information gathered by our analyzers establishes the following points: In view of these results, we argue that, in practice, a direct data flow analysis that relies on some amount of duplication would be as satisfactory as a CPS analysis.

Live-structure dataflow analysis for Prolog

For the class of applicative programming languages, efficient methods for reclaiming the memory occupied by released data structures constitute an important aspect of current implementations. The present article addresses the problem of memory reuse for logic programs through program analysis rather than by run-time garbage collection. The aim is to derive run-time properties that can be used at compile time to specialize the target code for a program according to a given set of queries and to automatically introduce destructive assignments in a safe and transparent way so that fewer garbage cells are created. The dataflow analysis is constructed as an application of abstract interpretation for logic programs. An abstract domain for describing structure-sharing and liveness properties is developed as are primitive operations that guarantee a sound and terminating global analysis. We explain our motivation for the design of the abstract domain, make explicit the underlying implementation assumptions, and discuss the precision of the results obtained by a prototype analyzer.

A rule based programming language for real-time applications

This paper presents a language based on production rules that integrates methods of procedural and heuristic programming, and has real-time operation capability. An interpreter was developed for executing programs written in this language under MSDOS environment. Several test programs were executed, and their results are stated from both formal aspects and execution time.

C Versus Fortran-77 for Scientific Programming

The predominant programming language for numeric and scientific applications is Fortran-77 and supercomputers are primarily used to run large-scale numeric and scientific applications. Standard C* is not widely used for numerical and scientific programming, yet Standard C provides many desirable linguistic features not present in Fortran-77. Furthermore, the existence of a standard library and preprocessor eliminates the worst portability problems. A comparison of Standard C and Fortran-77 shows several key deficiencies in C that reduce its ability to adequately solve some numerical problems. Some of these problems have already been addressed by the C standard but others remain. Standard C with a few extensions and modifications could be suitable for all numerical applications and could become more popular in supercomputing environments.

C for numerical computing

The predominant programming language for numerical and scientific applications is Fortran, and super-computers are primarily used to run large-scale numerical and scientific applications. C is not widely used for numerical and scientific programming, yet C provides many desirable linguistic features not present in Fortran-77. Furthermore, the existence of a standard library and preprocessor eliminates the worst portability problems. A comparison of C and Fortran-77 shows several key deficiencies in C that reduce its desirability for some numerical problems. Some of these problems have already been addressed by the new ANSI standard for C, but others remain. C with a few extensions and modifications could be suitable for all numerical applications and could become more popular in supercomputing environments.

A VLSI implementation of an architecture for applicative programming

The Applicative Programming System Architecture contains a novel Data Structure Memory (DSM) which supports fast access operations on compact linear data structures. Several problems that arise in implementations of applicative and functional programming languages can be solved efficiently using special data representations on the DSM. Each memory word in the DSM contains a very small local processor, and there is also a tree-structured communications network within the DSM. Therefore the DSM is a massively parallel SIMD machine. This paper describes a VLSI implementation of the DSM architecture and compares its performance with implementations on a conventional sequential computer and the NASA Massively Parallel Processor.

Debugging in applicative languages

Applicative programming languages have several properties that appear to make debugging difficult. First, the absence of assignment statements complicates the notion of changing a program while debugging. Second, the absence of imperative input and output makes it harder to obtain information about what the program is doing. Third, the presence of lazy evaluation prevents the user from knowing much about the order in which events occur. Some solutions to these problems involve nonapplicative extensions to the language. Fortunately, the same features of applicative languages that cause problems for traditional debugging also support an idiomatic applicative style of programming, and effective debugging techniques can be implemented using that style. This paper shows how to implement tracing and interactive debugging tools in a purely applicative style. This approach is more flexible, extensive and portable than debugging tools that require modification to the language implementation.

Socrates: a project integrating human science with computer science

This paper regards a project whose design objective was a synthesis of two perspectives on the use of computers in education. Computers may be used to educate, and people may be educated to use computers. Socrates is a project in the area of expert systems development. It was designed to be a workable tool in the field of abnormal psychology, but the educational setting was prominent during the design process. The tool chosen for development was a diagnostic expert system capable of producing a valid, reliable diagnosis on Axes I and III of the American Psychiatric Association's Diagnostic and Statistical Manual, Third Edition (DSM-III) of alcohol-use related maladaptive behavior patterns. The development of Socrates was approached using some of the perspectives that software engineers bring to the development of complex software systems. However, using algorithmic tools to solve a problem that is answerable only through heuristics renders those tools less useful. The system, implemented in PROLOG, was constructed from complex functional representations of data. Data flow diagrams (DFDs) tended to distort the exact picture of the system's functioning. If we simply rename the tool "Logical Instantiation Diagram" (LID), the psychological limitations of DFD's are eliminated since there is no longer any demand to adhere to DFD convention. Naturally, a project of this complexity involves the programmers very deeply in the implementation environment. PROLOG was studied as an applicative programming language, and yet it was discovered that it is possible to force procedurality onto PROLOG. The bridge between learning about expert system development and integrating the domain of a particular system is knowledge engineering. Here the emphasis is not on specialized programming techniques, but on the programmer's ability to reason inside the problem domain and to communicate that reasoning through the language at hand, be it LFD's actual PROLOG code, or the code of some other computer language. The knowledge engineer will come to recognize ways of thinking that are perhaps not included in a traditional programming discipline. Socrates is more than a project in expert system design; it is a study of learning. The project progressed from difficulties in representing ambiguous situations unambiguously to the recognition that the chief domain document is flawed inherently, as is any system which applies a finite number of classifications to an infinite number of possibilities. We propose Socrates as a model of liberal arts education. As a study of knowledge engineering it unites two distinct disciplines in a program of joint discovery. In working on Socrates we were able to develop specific ideas about the nature of our implementation, we made observations about the environment in which we were working, and finally, we were able to generalize the tools used in other areas of software development adapting them effectively to our own uses.

The key of Lisp

This is the first of what are hoped to be a series of columns devoted to presenting the point of view of the users of LISP. There are two conditions needed to support a column of this kind. The first and most important is that real users of LISP exist in the real world. I am not talking about university types, implementers of large software packages, or researchers in high-priced think tanks. I am talking about the possibility that there are application programmers in various companies spread across the breadth of the land (world?) who are turning to LISP as a viable programming language for applications instead of using FORTRAN, C, Ada, or even (heaven forbid) COBOL.

Program Structure Charts for Applicative Languages

A framework for a system of charts compatible with the use of applicative programming languages is proposed and illustrated. The charts are similar in spirit to the structured flowcharts that have sometimes been used with algorithmic languages. They are based on a method of representing the structure of nested expressions of arbitrary complexity. This method is adaptable to the incorporation of graphical devices for the depiction of local identifier bindings, conditional expressions, recursive function definitions, and the various functional combining forms employed in the FP-style of applicative programming.

GALILEO: a strongly-typed, interactive conceptual language

Galileo, a programming language for database applications, is presented. Galileo is a strongly-typed, interactive programming language designed specifically to support semantic data model features (classification, aggregation, and specialization), as well as the abstraction mechanisms of modern programming languages (types, abstract types, and modularization). The main contributions of Galileo are (a) a flexible type system to model database structure and semantic integrity constraints; (b) the inclusion of type hierarchies to support the specialization abstraction mechanisms of semantic data models; (c) a modularization mechanism to structure data and operations into interrelated units (d) the integration of abstraction mechanisms into an expression-based language that allows interactive use of the database without resorting to a new stand-alone query language. Galileo will be used in the immediate future as a tool for database design and, in the long term, as a high-level interface for DBMSs.

PAUL – A Programming Language for Knowledge Engineering Applications

This paper describes the design of PAUL, a programming language developed for knowledge engineering applications. PAUL is an object oriented language which uses dependency structures in order to allow efficient caching of deduced values without burdening the user with the task to maintain the consistency of a knowledge base himself. PAUL integrates several powerful ideas such as property inheritance, message passing, attached rules and filler types which all have been adapted to the dependency machinery.

Sequential algorithms on concrete data structures

We provide a sequential denotational semantics for sequential programming languages, based on a new notion of sequential algorithm on the Kahn-Plotkin concrete data structures. Intuitively an algorithm may be seen either as a concrete object—a “program” in a simple output-driven language — or as an abstract object — the pair of a sequential function and of a computation strategy for it. The concrete and abstract presentations are equivalent, as shown by a representation theorem. The algorithms form a cartesian closed category with straightforward solutions to recursive domain equations. Hence they may replace functions in the denotational semantics of any sequential language. An applicative programming language based on sequential algorithms is presented in a companion paper.

Performance of a multiprocessor for Applicative programs

Applicative programming Languages provide opportunities for parallel processing without requiring the programmer to be concerned with explicit synchronization of portions of the computation. We present a computational model of a multiprocessor which executes applicative programs, and we analyze the expected performance of the model via simulation. As the number of processors is doubled, elapsed execution time is nearly halved, until system bottlenecks occur. An alternative model is proposed which alleviates these bottlenecks. The basis of the second model is an interconnection switch which is characterized by log(n) access time and n log(n) cost.

G11.2 : The Impact of Distributed Computer Control Systems on Software

During the past years demands for automation of technical systems, generated the todays structural change from centralized, single computer control systems to distributed computer control systems. The results of this change are - on the one hand - improved capabilities and properties of the automation hardware system; on the other hand there is a risk of increasing software expenditure due to those structural properties of distributed computer systems. This paper starts from anylysis of the impact of distributed computer control systems on software and shows, that - in the field of application programming only higher level languages or problem-oriented languages will cope with the arising problems. The necessary supporting system programs are introduced, but the main importance is attached to the design of a well suited application programming language. This language design is derived from two assessments using systems and decision theory and is classified into a hierarchy of application programming aids. The realization of the language design is based on the existing language PEARL (Process and Experiment Automation Realtime Language), which has to be extended (but not altered) for the description of structural and fault tolerance features of distributed computer control systems. The implemented language elements are explained by examples. A final view of the utilization of higher level languages for distributed microcomputer systems considers the rapid development in this field of hardware

Programming Distributed Computer Systems with Higher Level Languages

During the past few years the increasing demands for system automation, together with the progress in VLSI-semiconductor technology, have introduced distributed computing systems, yielding the potential of higher performance and higher availability. Those hardware properties have to be accompanied by suitable programming aids to make them explicitely usable for the application programmer. In addition, software costs have to be maintained at the same level as the software costs for centralized systems.Our approach to suitable programming aids starts from two theoretical assessments using systems theory and decision theory. The requirements and the design of a higher level application programming language for distributed systems are derived from these assessments. The realization of this language design employs a value analysis of existing languages to determine the best suited candidate for the basic requirements. The language chosen is PEARL (Process and Experiment Automation Realtime Language) which has to be extended for the requirements of distributed computer systems. These extensions - not altering basic PEARL itself but adding new language elements - are described in some detail together with supporting system programs. The PEARL-extensions provide means for the description of hard- and software structures and/or configurations, as well as the explicit formulation of exception handling, i.e. reactions on non-regular system-states, where the “system-state” is given by the actual values of a set of system-variables. Finally this lang uage is classified into a hierarchy of language levels ranging from very high languages to system development languages.

The design of a global optimizer

We are constructing a compiler for a high level systems and applications programming language. Because the compiler is required to generate efficient object code, a global optimization phase and register allocation phase are an integral part of the design. It was determined that the familiar optimizations of code motion, redundant expression elimination, and dead code removal would be sufficient. The optimizer design was to be based on the most recent applicable theoretical results, yet simple and straightforward to implement. Traditional approaches were considered inadequate because they assume a primitive intermediate code representation (quadruples), elaborate flow graph constructions, and numerous special cases. High level data flow analysis as proposed by Rosen [1,2] provided the framework we sought. Using his approach, the parse tree of the program, with its high level control structures intact, becomes a suitable intermediate representation. Complex statement structures are analyzed quickly in two tree traversals to determine the solutions to data flow problems.

A very high level programming language for data processing applications

Application development today is too labor-intensive. In recent years, very high-level languages have been increasingly explored as a solution to this problem. The Business Definition Language (BDL) is such a language, one aimed at business data processing problems. The concepts in BDL mimic those which have evolved through the years in businesses using manual methods. This results in three different sublanguages or components: one for defining the business forms, one for describing the business organization, and one for writing calculations.