A technique for representing programs abstractly and independently of the eventual target architecture is presented that yields a file representation twice as compact as machine code for a CISC processor. It forms the basis of an implementation, in which the process of code generation is deferred until the time of loading. At that point, native code is created on_the_fly by a code_generating loader. The process of loading with dynamic code_generation is so fast that it requires little more time than the input of equivalent native code from a disk storage medium. This is predominantly due to the compactness of the abstract program representation, which allows to counterbalance the ad...

We present a general model of software development environments that consists of three components: structures, mechanisms and policies. The advantage of this model is that it distinguishes intuitively those aspects of an environment that are useful in comparing and contrasting software development environments. Our initial application of the model is to characterize four classes of environments by means of a sociological metaphor based on scale: the individual, the family, the city and the state models. The utility of the IFCS taxonomy is that it delineates the important classes of interactions among software developers and exposes the ways in which current software development environments inadequately support the development of large systems. We demonstrate the generality of our model by also applying it to a previously published taxonomy that categorizes environments according to how they relate to four historical trends: language-centered, structure-oriented, toolkit and method-bas...

A systematic approach is given for deriving incremental programs from non-incremental programs written in a standard functional programming language. We exploit a number of program analysis and transformation techniques and domain-specific knowledge, centered around effective utilization of caching, in order to provide a degree of incrementality not otherwise achievable by a generic incremental evaluator. 1 Introduction Incremental programs take advantage of repeated computations on inputs that differ only slightly from one another, avoiding unnecessary duplication of common computations. Given a program f and a certain input change \Phi, a program f 0 that computes the value of f(x \Phi y) efficiently by making use of the value of f(x) is called an incremental version of f under \Phi. The parameter y can be regarded as a change ffix to the input x. Methods of incremental computation have widespread applications, e.g., loop optimizations in optimizing compilers [1, 24, 9, 10] and ...

Powerful editing systems for developing complex software documents are difficult to engineer. Besides requiring efficient incremental algorithms and complex data structures, such editors must integrate smoothly with the other tools in the environment, maintain a sharable database of information concerning the documents being edited, accommodate flexible editing styles, provide a consistent, coherent, and empowering user interface, and support individual variations and project-wide configurations. Pan is a language-based editing and browsing system that exhibits these characteristics. This paper surveys the design and engineering of Pan, paying particular attention to a number of issues that pervade the system: incremental checking and analysis, information retention in the presence of change, tolerance for errors and anomalies, and extension facilities.

Abstract not found

We describe the Linda Program Builder --- a higher-level programming environment that supports the design and development of parallel software. It isolates much of the administrative effort in constructing parallel programs, and maintains a program-describing database. This database feeds information to the compiler for optimization, to a visualizer for enhanced program visualization, and potentially to other tools in the environment. The LPB is a window-oriented, menu-based, user-friendly system which provides coordination frameworks for program construction. These templates or coordination frameworks themselves can be custom-constructed by invoking a template-building template; most importantly, the LPB represents the idea of an "open" or "dynamic" preprocessor as an alternative to new programming languages . This research is supported by National Science Foundation grant CCR-8657615, by the Air Force Office of Scientific Research under grant number AFOSR-91-0098, and by Scientific...

Abstract-This paper introduces the concept ofan integrated instrumentation environment (IIE) for multiprocessors. The primary objective ofsuch an environment is to assist the user in the process of experimentation. Theemphasis in an IIE is on experiment management (including stimulus generation, monitoring, data collection and analysis), rather than on techniques for program development as in conventional programming environments. We believe the functionality of the two environments should eventually be provided in one comprehensive environment. An experiment schema is introduced as an appropriate structuring concept for experiment management purposes. Schema instances capture the results ofan experiment for later analysis.An example is developed in some detail to demonstrate the potential benefits ofsuch an approach. The three primary components of the IIE, namely, the schema manager, the stimulusgenerator, and the monitor, are briefly described. A preliminary implementation of the design on the Cm* multiprocessor is briefly discussed. Index Terms-Automated testing, experimentation, experiment management, instrumentation, monitoring, multiprocessor performance evaluation, programming environment, stimulus generation, workload generation. I.

“But to this day I thank my friends for constantly reminding me of a very important word called Persistence. Persistence is to the quality of the character of man, what carbon is to steel. ”- Billy Ray Cyrus

this paper we present an incremental LR parsing technique. The technique is applicable to all grammars in the LR, SLR, and LALR families. We present the technique in terms of the LR(1) grammars in this paper. The extension to other grammars should be obvious. An LR(1) parser maintains a stack of states, of which the top element is considered the current state of the parser. A state in the parse stack actually represents a subtree of the yet-to-be-built parse tree. Parsing operations are determined from the current state and the next look-ahead token. The parser performs two kinds of operations: shift and reduction. The shift operations correspond to state transitions on an LR(1) finite state machine [1]. As soon as the handle

This paper describes alternative ways to support this facility in the circumstance that this code is optimized away. Categories and Subject Descriptors: D.2.5 [Software Engineering]: Testing and Debugging --- debugging aids; D.2.6 [Software Engineering]: Programming Environments; D.3.4 [Programming Languages ]: Processors --- code generation, compilers, optimization