waashk/acm huggingface dataset:
oop vs. readability a previous paper discussed the relationship between the object-oriented-programming (oop) feature known in ada 95 as dispatching and ada's expressed design goal of emphasizing ease of reading and understanding over ease of writing [1]. a comparison of barnes' alert-system example [2] using ada-95 dispatching and using ada-83 composition showed that dispatching emphasized ease of writing over ease of reading, while composition emphasized ease of reading over ease of writing. this led to the conclusion that the goals of dispatching conflict with ada's expressed design goals.dispatching is half of oop; the other half is inheritance, correctly called type extension in ada 95. this paper examines the relationship between inheritance and ada's expressed design goal of emphasizing ease of reading and understanding over ease of writing.object-oriented design (ood), as introduced by booch [3], emphasizes the software-engineering principles of locality, encapsulation, and information hiding. ada 83 supports such ood well; using ood and ada results in easy-to-read programs that exhibit low coupling and high cohesion. ood is independent of oop: fully object-oriented designs may be implemented using composition methods familiar to ada-83 users without any need for oop features (inheritance and dispatching). oop features may likewise be used without ood. jeffrey r. carter
designing data entry programs using state diagram as a common model  a minicomputer based data entry system recently developed at bell laboratories supports 73 transaction types and approximately 1000 fields. the user communicates with the system from a crt terminal in field-by-field mode via a uniform interface. this paper presents a common design for the family of data entry programs that process the various types of transactions. the design is represented by a compact, orderly, and verifiable model to demonstrate the consistent program behavior. the model is formalized and proved correct to validate the design. the common model reduces design effort, provides design generality, enables code generation, and enhances ease of maintenance. the correctness proof eliminates high level design errors and their consequences. in the general area of business application, a common design lends itself to quickly mass produce components of a software product, and makes it easy to maintain them later.  moses m. ling
action language: a specification language for model checking reactive systems  we present a specification language called action language for model checking software specifications. action language forms an interface between transition system models that a model checker generates and high level specification languages such as statecharts, rsml and scr---similar to an assembly language between a microprocessor and a programming language. we show that action language translations of statecharts and scr specifications are compact and they preserve the structure of the original specification. action language allows specification of both synchronous and asynchronous systems. it also supports modular specifications to enable compositional model checking.  tevfik bultan
on the control dependence in the program dependence graph  the program dependence graph, pdg, is used to represent the data and control dependencies between the statements of some program. the data dependencies between the statements are fully understood and they correspond to the definition-use chain. on the other hand the concept of control dependence is not fully explored. in this paper we formalize and analyze the concept or control dependence and present algorithms to find directly the control dependence subgraph of pdg in  (n α(n)), where n is the number of statements in the program.  i. a. natour
software testing and the pabx  the topic of software testing is as general as the blue sky, and because software has become one of the key ingredients used to build machines, testing methodologies have become an important part of the overall software development cycle, particularly in highly demanding real time environments. a good software test insures that the machine performs in the manner envisioned by its creators. while testing can be done at many stages ranging from design and code reviews to low level testing of code at the procedure and subroutine level, the focus of this paper will be on testing the functional behavior of the end product. testing of a special class of machine, the private automatic branch exchange, (pabx) is discussed along with a novel approach which was developed and successfully applied. the pabx can be characterized as a finite state machine, but for testing purposes it has an almost infinite number of states to test. this paper will discuss the selection and formalization of an algorithmic testing notation and set of related procedures which insures stringent product quality goals while at the same time reducing the testing effort to a reasonable and manageable task.  john o.b. greaves art bailey
optimizing strategies for telescoping languages: procedure strength reduction and procedure vectorization  at rice university, we have undertaken a project to construct a framework for generating high-level problem solving languages that can achieve high performance on a variety of platforms.the underlying strategy, called _telescoping languages_, builds problem-solving systems from domain-specific libraries and scripting langauges. to accomplish this it extensively preanalyzes and transforms the library to produce a scripting language precompiler that optimizes library calls within the scripts as if they were primitives in the underlying language.  a major technical issue is how to preoptimize a library for use in applications that are yet to be seen. to address this issue, we have conducted a study of applications written in matlab by the signal processing group at rice university. this has identified a collection of old and new optimizations that show promise for this particular domain. two promising new optimizations are _procedure vectorization_ and _procedure strength reduction_.the latter of these is particularly useful in this problem domain and we expect it to be just as applicable in other contexts as well.  we report on the results of an exploration of the effectiveness of procedure strength reduction on three real digital signal processing (dsp) applications. by transforming these programs according to the strategies described in this paper, we were able to achieve speedups ranging from 10 to 40 percent over the entire application --- speedups for individual functions were even more dramatic.  arun chauhan ken kennedy
elan: an elementary language that promotes godd programming  the purpose of this paper is twofold: to consider the characteristics that a programming language for beginners ought to have, and to offer a new language from germany that shows great promise for providing beginners with many of these characteristics. this language is called elan (elementary language) and was designed in 1974 by c. h. a. koster and his associates at the technical university of berlin. an elan compiler was developed soon thereafter from two theses written by j. liedtke and u. bartling at the university of bielefeld. it is hoped that this paper will bring to elan some of the recognition that it deserves but has not yet received in this country.  lowell a. carmony
an examination of evolution dynamics  data on the history of seven systems was analysed to statistically test the 5 laws of software evolution proposed first by belady and lehman in 1976.  while there was some evidence supporting laws 1 and 2, laws 3-5 were not supported by the data. in the light of the result a new discontinuous model of software evolution is proposed to replace the smoothly changing continuous model proposed by lehman.  m. j. lawrence
generation of run-time environments  attribute grammars have been used for many years for automated compiler construction. attribute grammars support the description of semantic analysis, code generation and some code optimization in a formal declarative style. other tools support the automation of lexical analysis and parsing. however, there is one large part of compiler construction that is missing from our toolkit: run-time environments. this paper introduces an extension of attribute grammars that supports the generation of run-time environments. the extension also supports the generation of interpreters, symbolic debugging tools, and other execution-time facilities.  / gail e. kaiser
v-pascal: an automatic vectorizing compiler for pascal with no language extensions  detailed anatomy of automatic vectorizing compiler v-pascal (version 1, now operational) is given. with no language extensions, v-pascal efficiently vectorizes the whole of arbitrarily given multiply nested for loops using the mechanism of vector indirect addressing. higher functions of v-pascal, such as (a) vectorization of while-do and recursive calls, (b) vectorization of relational operations on relational database defined by record-type data structures, and (c) automatic parallel decomposition for multiprocessor environments, are considered for version 2 and are now in the process of design and implementation.  t. tsuda y. kunieda
implementing russell  we have completed an implementation of the russell programming language [don 85]. this effort has been very helpful in the evaluation of the original language design. it has also served to pinpoint the difficulties in implementing languages with type systems as general as that of russell.  russell treats both functions and types as data objects which can be freely manipulated by the program. most operators present in conventional programming languages are viewed as function calls. in spite of this, our compiler produces surprisingly efficient machine code, even with minimal effort invested in the code generator.  the generality of the language served to simplify some aspects of the compiler. we focus on the separate compilation mechanism.  the most difficult implementation problem is that of inferring typing information omitted by the programmer. we argue that this is an essential part of type checking a language such as russell. our current solution is only partially satisfactory.  hans-juergen boehm alan demers
implementing multiple locks using lamport's mutual exclusion algorithm  we describe an approach for implementing higher-level mutual- exclusion constructs using lamport's algorithm. a straightforward implementation of, for example, monitor locks based on lamport's algorithm requires o(n) space per monitor lock if there are n processes that may share the lock. it has occasionally been claimed that this makes the algorithm undesirable in practice. the insight presented here is that we only need a (small) constant amount of space per lock, plus o(n) space shared by all locks in the system. for some common applications, this adds no memory references to the implementation of the algorithm. fully general spin-lock acquisition and release can usually be implemented with the addition of one memory reference to lamport's algorithm. on particularly unfavorable hardware, three additional memory references may be required in the contention-free case.  hans-j. boehm alan j. demers chris uhler
the document editor: a support environment for preparing technical documents  as understanding of a particular problem domain matures, its tools become more specialized, moving from general low-level tools to more specialized high- level tools. early work in a field applies the same set of low-level aids to all problems. gradually more specialized tools emerge as we come to better understand the problem and the tools that are best for it.  since the emergence of the first program editors in the early 1960s we have learned a lot about the editing process and about building editors. recently several editors specialized for editing program sources, text, and data structures have been developed. to date, little work has been reported on specialized document editors for editing complex text. this paper describes a research effort into identifying the requirements for an interactive environment for editing complex documents and an initial implementation for the environment.  janet h. walker
sifting out the gold: delivering compact applications from an exploratory object-oriented programming environment  integrated, dynamically-typed object-oriented programming environments offer many advantages, but have trouble producing small, self-contained applications. recent advances in type inference have made it possible to build an application extractor for self. the extractor was able to extract a medium- sized application in a few minutes. the extracted application runs in a tenth the space of the original environment. except for extracting reflection and sends with computed selectors, the extractor runs without human intervention and fully preserves the behavior of the application.  ole agesen david ungar
ans mumps in a multi-lingual operating system  i have often wondered why the people of the world do not have one common language. yet my international traveling experiences have shown me that i must accept a multi- lingual world and adjuster to it. likewise, the computer industry has its reasons, deeply imbedded in the process of evolution, for being multi-lingual. as we move into the decade of the 80's, computer users are not going to find selection of software and hardware any easier than in the 70's. the trade-offs between developing your own custom software and adapting to available products may be even more complex.  one thing is certain as we enter the 80's: the decrease in cost of hardware, such as micro systems and user terminals, is rapidly bringing computer power to the home and office for more routine use. as equipment becomes more commonly used, user interface software must adjust to meet the needs of: (a) less sophisticated computer users, and (b) sophisticated users who continually seek more power and versatility at their finger tips. it is into this environment that mumps takes its place, as though timely created for a key role as an interface language between the user and his machine.  hollis v. arban
a concurrent compiler for modula-2+  in this paper we describe a collection of techniques for the design and implementation of concurrent compilers. we begin by describing a technique for dividing a source program into many streams so that each stream can be compiled concurrently. we discuss several compiler design issues unique to concurrent compilers including source program partitioning, symbol table management, compiler task scheduling and information flow constraints. the application of our techniques is illustrated by a complete design for a concurrent modula-2+ compiler. after describing the structure of this compiler's performance that demonstrates that significant improvements in compilation time can be achieved through the use of concurrency.  david b. wortman michael d. junkin
onion: a methodology for developing data-dominant systems from building blocks  this paper describes the onion development methodology for building data- dominant systems, i.e., systems where the primary concern is the integrity of the data store. onion shows how to identify, specify, and implement a hierarchy of abstract data types (adts) as building blocks, based on an idef1 conceptual data model. also, onion shows how the building blocks can be used to synthesize system-level operations. the adts are specified algebraically and implemented in a language that supports adts, such as ada. the methodology is illustrated using a library information system as an example.  arun p. gupta paul c. grabow
characteristic program complexity measures  twenty program complexity measures are studied with respect to how well they identify the more complex procedures in a software system. the measures have been applied to three large sets of pl/i procedures representing three different types of applications. four of these complexity measures have been found to form a characteristic set. that is, when procedures are kept within reasonable bounds for the four selected measures, they will most likely be within reasonable bounds for all of the other measures. the measures and their interpreted meanings are  length---the quantity of source code,  unique operators---the variety of programming language actions,  data difficulty---the average number of variable appearances, and  unique operands---the variety of constants and variables.  james l. elshoff
multi-model parallel programming in psyche  many different parallel programming models, including lightweight processes that communicate with shared memory and heavyweight processes that communicate with messages, have been used to implement parallel applications. unfortunately, operating systems and languages designed for parallel programming typically support only one model. multi-model parallel programming is the simultaneous use of several different models, both across programs and within a single program. this paper describes multi-model parallel programming in the psyche multiprocessor operating system. we explain why multi-model programming is desirable and present an operating system interface designed to support it. through a series of three examples, we illustrate how the psyche operating system supports different models of parallelism and how the different models are able to interact.  m. l. scott t. j. leblanc b. d. marsh
estimation of software reliability by stratified sampling  a new approach to software reliability estimation is presented that combines operational testing with stratified sampling in order to reduce the number of program executions that must be checked manually for conformance to requirements. automatic cluster analysis is applied to execution profiles in order to stratify captured operational executions. experimental results are reported that suggest this approach can significantly reduce the cost of estimating reliability.  andy podgurski wassim masri yolanda mccleese francis g. wolff charles yang
generating environments for programming-in-the-large  in order to provide better programming environments, language-based tools are introduced. these are tools which use knowledge of a programming language's structure to provide special program development facilities. however, current software environment generators are geared towards generating environments which have language-based tools for programming-in-the-small only. they generate environments with language-based syntax-directed editors [1,2,3].  further improvements for programming environments could be achieved by extending the concept of providing language-based tools to include tools for programming-in-the-large [4]. to create a new environment, the designer supplies a declarative description for the target programming language objects and their interactions. the description of the programming language objects is given in a meta language based on the e-r model. the environment generator then processes and links this information together with a kernel supplied by the generator to produce a new environment. all the generated environments will have a uniform data model representing programs. a program is represented as a set of attributed entities which are linked together by a set of relations. the generated environments are a collection of integrated tools which are tailored according to the definition of the target programming language as well as tools which are standard for all environments (kernel) and do not depend on a language. below is a brief description of these tools.  graphical interface manager: this tool represents the communication medium between the user and the environment. it interprets the user's command and accordingly invokes the relevant system component which, in turn, will perform the operation requested by the user.  system manager: it contains a set of operations which allow the user to save, load, and initialize the objects of software system stored in the database. it also contains operations for executing the code generated from the information stored in the database.  entity editor: used to build and manipulate the architecture of a program. with this tool, software objects and their relationships can be added or deleted.  browser: it provides mechanisms to display information. the main feature of the browser, is the support for displaying multiple views of a program through multiple windows. each window is equipped with mechanisms to invoke all the tools in the environment.  information viewer: views are subsets of a software system graph. they contain a particular structural information. information viewer displays such information based on criteria set by the user.  database: it is a repository of all the information about software components and their interconnections.  parser: extracts all entities and their relations which appear in a source code and stores them in the database.  wafa khorshid
using static single assignment form in a code optimizer  static single assignment form represents data dependences elegantly and provides a basis for powerful optimizations. table-driven techniques for peephole optimization and code generation are straightforward and effective. it is natural to want to use both together in a code optimizer. however, doing so reveals that static single assignment form does not remove all antidependences, and that it conflicts with table-driven code generation for 2-address machines. this paper describes these problems and how to solve them.  carl mcconnell ralph e. johnson
a comparative study of static and profile-based heuristics for inlining  in this paper, we present a comparative study of static and profile- based heuristics for inlining. our motivation for this study is to use the results to design the best inlining algorithm that we can for the jalapeño dynamic optimizing compiler for java [6]. we use a well- known approximation algorithm for the knapsack problem as a common "meta-algorithm" for the inlining heuristics studied in this paper. we present performance results for an implementation of these inlining heuristics in the jalapeño dynamic optimizing compiler. our performance results show that the inlining heuristics studied in this paper can lead to significant speedups in execution time (up to 1.68x) even with modest limits on code size expansion (at most 10%).  matthew arnold stephen fink vivek sarkar peter f. sweeney
analyzing aliases of reference formal parameters  compilers for languages with call-by-reference formal parameters must deal with aliases arising from the renaming effects at call sites. this paper presents a set of techniques for analyzing aliasing patterns. the analysis is divided into detecting the introduction of aliases and tracking their propagation. the algorithm for introduction analysis is simple enough to be performed in a structured editor or parser. a data flow analysis framework is given for the propagation problem, making it possible to solve using standard algorithms from global data flow analysis. several optimizations are shown which can shrink the size of the problem, and extensions are given to handle algol-style name scoping. finally, this technique is compared to an alternative implementation strategy and an approximate technique.  keith d. cooper