PEP: An interactive programming system with an Algol-like programming language

PEP (Program Editor and Processor) is an interactive programming system based on an Algol-like language. It is intended to replace BASIC as a system for interactive program development on small computers (LSI-11). The language processed by the system allows declaration of variables, constants and procedures; it has structured statements for conditional and repetitive execution of program parts. We describe design and implementation of the system and give our impressions after 1 year of experience with the system.     

Compiler to interpreter: experiences with a distributed programming language

One interpretive approach for handling concurrency is to provide an interpreter instance for each executing language‐level process. Such an approach has mainly been applied to concurrent implementations of logic and functional languages. This paper describes the use of this approach in constructing an interpreter for an imperative, distributed programming language from an existing compiler and run‐time support system (RTS). Primary design goals were to exploit the existing compiler to the extent possible as well as to have minimal impact on the RTS used to support concurrency. We have been successful in meeting these goals. Additionally, performance results show our interpreter's execution times compare favorably to the times required for compilation, linkage, and execution of small programs or programs with a significant number of calls to the RTS; on such programs, our interpreter's performance also compares favorably to that of the standard Java implementation. However, for larger programs and programs with fewer calls to the underlying RTS, the conventional compiler‐based implementation outperforms the interpreter implementation. For many distributed programs in which network costs dominate, the performances of the two implementations differ little. Copyright © 2001 John Wiley & Sons, Ltd.     

Solutions to four open problems concerning controlled pure grammar systems

In this paper, we address several open problems concerning pure grammar systems (pGSs) and their controlled versions. More specifically, we prove the following four results. (I) Regular-controlled pGSs having a single component define the family of regular languages. (II) pGSs having two components controlled by infinite regular languages define the family of recursively enumerable languages. (III) Regular-controlled pGSs without any erasing rules define the family of regular languages not containing the empty string. (IV) pGSs define a proper subfamily of the family of regular languages.     

Interpretation control using a linear tree representation

A linear tree structure is considered for the internal representation of programs executed by interpreters. This representation is appropriate when one wishes to have an internal representation preserving the high level structures of the source language. The linear tree structure facilitates a simple mechanism for interpretation control in the context of high level control structures.     

Interactive development of object handling programs

We describe work on development of a software system for writing and testing programs for a computer controlled manipulator. We examine in particular how the development of working programs is facilitated by the use of an interactive system based on an interpreter. The paper presents the main features of POINTY, the system developed at Stanford Artificial Intelligence Laboratory as a tool for writing assembly programs. The user, interacting with the manipulator, constructs an incremental model of the objects involved in the assembly and develops the corresponding symbolic program.     

How well does a vanilla loop fit into a frame?

The frame language FRL is compared with some newer object-oriented languages, namely LOOPS, the Flavor System and the Poor Man's Flavor System. The kernel features are investigated in detail and a simulation of FRL in the Flavor System is performed. The conclusion is that in general the object-oriented languages cannot be easily utilized as a substitute for FRL frames because of the different view these languages have of objects, but there are important special cases where object-oriented languages are very similar to FRL.     

An attribute grammar approach to compiler optimization of intra-module interprocess communication

Earlier work has shown the effectiveness of hand-applied program transformations optimizing high-level interprocess communication mechanisms. This paper describes the static analysis techniques necessary to ensure correct compiler application of the optimizing transformations. These techniques include both dataflow analysis and interprocess analysis. This paper focuses on the analysis of communication mechanisms within program modules; however, the analysis techniques can be generalized to handle inter-module optimization analysis as well. The major contributions of this paper include the application of dataflow analysis and the extension of interprocedural analysis—interprocess analysis—to real concurrent programming languages and, more specifically, to the optimization of interprocess communication and synchronization mechanisms that use both static and dynamic channels. In addition, the use of attribute grammars to perform interprocess analysis is significant. This paper also describes an implementation of both intra-process dataflow and interprocess analysis techniques using attribute grammars.This work was supported by NSF under Grant Number CCR88-10617.     

- : an executable specification language for solving all problems in NP

In this paper a logic-based specification language, called - , is presented. The language is obtained by extending through allowing a limited use of some second-order predicates of predefined form. - programs specify solutions to problems in a very abstract and concise way, and are executable. In the present prototype they are compiled to code, which is run to construct outputs. Second-order predicates of suitable form allow to limit the size of search spaces in order to obtain reasonably efficient construction of problem solutions. - expressive power is precisely characterized as to express exactly the problems in the class NP. The specification of several combinatorial problems in - is shown, and the efficiency of the generated programs is evaluated.     

Frameworks compiled from declarations: a language‐independent approach

Programming frameworks are an accepted fixture in the object‐oriented world, motivated by the need for code reuse, developer guidance and restriction. A new trend is emerging where frameworks require domain experts to provide declarations using a domain‐specific language, influencing the structure and behaviour of the resulting application. These mechanisms address concerns such as user privacy. Although many popular open platforms such as Android are based on declaration‐driven frameworks, current implementations provide ad hoc and narrow solutions to concerns raised by their openness to non‐certified developers. Most widely used frameworks fail to address serious privacy leaks and provide the user with little insight into application behaviour. To address these shortcomings, we show that declaration‐driven frameworks can limit privacy leaks, as well as guide developers, independently from the underlying programming paradigm. To do so, we identify concepts that underlie declaration‐driven frameworks and apply them systematically to an object‐oriented language, Java and a dynamic functional language, Racket. The resulting programming framework generators are used to develop a prototype mobile application, illustrating how we mitigate a common class of privacy leaks. Finally, we explore the possible design choices and propose development principles for developing domain‐specific language compilers to produce frameworks, applicable across a spectrum of programming paradigms. Copyright © 2016 John Wiley & Sons, Ltd.     

An Introduction to SequenceL: A Language to Experiment with Constructs for Processing Nonscalars

SequenceL is a language intended for experimentation with declarative constructs for nonscalar processing. In SequenceL, a problem solver provides little in the way of iterative/recursive details in a problem solution. Instead, the problem solver describes the solution directly by specifying, via a metastructure, the data structures which will hold results useful for solving the problem. SequenceL is a small language (i.e. there is a small number of language constructs), and it is not domain dependent. This paper is meant to introduce the reader to SequenceL.