waashk/acm huggingface dataset:
towards a theory of packages  a model for packages is introduced, along with operations for their manipulation. the model is based on the unifying principle that programs should be represented by trees, and packages by substitutions on trees. operations are defined on packages, that allow the construction of any package from a collection of basic packages. a programming environment, based on this model, would allow manipulations and operations that are not possible in current languages. information hiding and encapsulation are automatically supported by the model. a typing mechanism is presented, which allows polymorphic types. the typing does not affect the typeless aspect of the model.  snorri agnarsson m. s. krishnamoorthy
a survival strategy for apl  echoing the concerns of the conference call for papers, apl no longer holds the market niche which it once had - over the past few years new developments in the world of computing have overtaken many of the areas which were once our exclusive province.  given that the computing industry is one which focuses hard on 'winners', we have to ask ourselves whether or not there is a long-term place for apl, what that place might be and how we can attain it.  the contention of this paper is that an honorable future for apl can be found and that we can reach this position more easily if we work toward it together the exact path to be outlined here is not necessarily the 'correct' one but at the present stage of the game our most urgent need is to consider as many of the facts as we can muster.  dick bowman
machine-adaptable dynamic binary translation  dynamic binary translation is the process of translating and optimizing executable code for one machine to another at runtime, while the program is "executing" on the target machine.  dynamic translation techniques have normally been limited to two particular machines; a competitor's machine and the hardware manufacturer's machine. this research provides for a more general framework for dynamic translations, by providing a framework based on specifications of machines that can be reused or adapted to new hardware architectures. in this way, developers of such techniques can isolate design issues from machine descriptions and reuse many components and analyses.  we describe our dynamic translation framework and provide some initial results obtained by using this system.  david ung cristina cifuentes
data abstraction from a programming language viewpoint  this paper traces the development of data abstraction concepts in programming languages. a data abstraction, or abstract data type, describes a collection of abstract entities and operations on the entities. a program which uses a data abstraction can access or modify the entities only through the abstract operations.  specific research topics discussed in the paper include: the role of type in a programming language, the formal specification of the semantics of a data abstraction, data abstraction language construct design issues, type hierarchies, and type-checking.  lawrence a. rowe
improved sharing of apl workspaces and libraries  years of experience have revealed deficiencies in apl's traditional library structure and its facilities for managing saved workspaces. as part of the development of a new file system, stsc undertook to resolve these deficiencies in a revised design. the rules governing the use of shared workspaces have been broadened and placed under the control of an access matrix, giving the user great flexibility in controlling how invidual workspaces are used. apl libraries have been generalized and likewise placed under access-matrix control. system facilities are provided that allow any workspace-management action to be performed under program control.  the concept of the apl workspace has hardly changed since the earliest apl systems; it is worthwhile to wonder why. to programmers weary from battling the job control languages of that era's operating systems, the workspace must have seemed a concept of charming and startling simplicity. to the computer novice, who found in apl a shortcut through the maze of technical lore, the notion of the workspace was quickly assimilated into intuition.  james g. wheeler
fault classes and error detection capability of specification-based testing  some varieties of specification-based testing rely upon methods for generating test cases from predicates in a software specification. these methods derive various test conditions from logic expressions, with the aim of detecting different types of faults. some authors have presented empirical results on the ability of specification-based test generation methods to detect failures. this article describes a method for cokmputing the conditions that must be covered by a test set for the test set to guarantee detection of the particular fault class. it is shown that there is a coverage hierarchy to fault classes that is consistent with, and may therefore explain, experimental results on fault-based testing. the method is also shown to be effective for computing mcdc-adequate tests.  d. richard kuhn
an overview of common lisp  a dialect of lisp called "common lisp" is being cooperatively developed and implemented at several sites. it is a descendant of the maclisp family of lisp dialects, and is intended to unify the several divergent efforts of the last five years. we first give an extensive history of lisp, particularly of the maclisp branch, in order to explain in context the motivation for common lisp. we enumerate the goals and non-goals of the language design, discuss the language features of primary interest, and then consider how these features help to meet the expressed goals. finally, the status (as of may 1982) of six implementations of common lisp is summarized.  guy l. steele
adding parametric polymorphism to the common object request broker architecture (corba) (poster session)  the research displayed in this poster showcases issues surrounding adding parametric polymorphism to corba. the merits of parametric polymorphism are widely published, yet there is no support for the parametric polymorphism paradigm in corba. this research should be of special interest to c++ programmers, and other programmers accustomed to generic programming, frustrated by this lack of support.  wayne l. bethea
analysis is necessary, but far from sufficient (abstract only): experiences building and deploying successful tools for developers and testers  why are there so few successful "real-world" programming and testing tools based on academic research? this talk focuses on program analysis tools, and proposes a surprisingly simple explanation with interesting ramifications.  for a tool aimed at developers or testers to be successful, people must use it - and must use it to help accomplish their existing tasks, rather than as an end in itself. if the tool does not help them get their job done, or the effort to learn and/or use the tool is too great, users will not perceive enough value; the tool will not get significant usage, even if it is free.  this talk focuses on the often- overlooked consequences of this seemingly basic statement in two major areas: program analysis, and the work beyond core analysis that must be done to make a successful tool. examples will be drawn from tools that have been successfully used in industry (sold commercially, and developed for internal use).  jon pincus
what is the proper size of a program module? (abstract only)  there are a variety of views about structured programming, and thus a number of ways to describe it. however, we all know that a well structured program must be easy to read and easy to modify. as a consequence, modularity become a central concept in structured programming.  automobiles are assembled from components (i.e. modules) instead of individual parts, so that their structure look simple, and thus easier for auto - mechanics to handle the necessary repairs.  the human ability in handling complexity is limited by their short term memory capacity, which has been known to range from 5 to 9 simultaneous facts. however, computer programs contain statements presented on a medium such as paper, and nobel-prize winner psychologist herbert simon once suggested that the short term memory capacity on paper for humans exceeds that in human brain.  the short term memory capacity has been used successfully, in our class, as a guideline in setting the size for program modules. the readability of the student programs was markedly improved, and thus greatly reduced the time needed for grading the programs.  a main program usually contains a larger number of declarations (non-active statements) than that of a sub-program; but each one of them is a program module. thus, our class had, after discussion, chosen to limit each program module to no more than 12 active statements. as a result, the student programs were much easier to read.  we are currently studying the possibility of establishing a more comprehensive measure for module complexity that is easy to use. guided by researches on measuring the readability of natural language texts, we are exploring the following:  counting the number of identifiers declared as constants, types, and variables.  counting the number of operators in each active statement and considering the use of different operators as more complex than the repetition of the same operator.  determining to what extent some active statements, such as do loop and conditional branches, should be assigned a larger count; because they appear to be more complex than assignment statement.  these ideas and others will be discussed during our presentation. colleagues in the audience will be invited to offer their ideas and suggestions for further studies.  note: a part of this paper's content was presented by yin-min wei at the 1985 ohio computer science colleague's conference, bowling green state university, ohio  yin-min wei edgar howell
prism - productivity improvement for software engineers and managers  an integrated set of tools to support top---down, structured software design is described. the tools provide multiple views of the design process and share a common, iconic user interface among themselves and with an extensive set of office system utilities. the multiple design views are supported by a multiple window operating system running on a high performance microcomputer with a high resolution, bit---mapped display and a mouse. the system provides support for proven software engineering methodologies from data flow design through software maintenance. high quality documentation is automatically produced during each phase of the design. the tool set is language---independent and open---ended for ease of future expansion.  doug rosenberg
a good hoare axiom system for an algol-like language  clarke has shown that it is impossible to obtain a relatively complete axiomatization of a block-structured programming language if it has features such as static scope, recursive procedure calls with procedure parameters, and global variables, provided that we take first-order logic as the underlying assertion language [cl]. we show that if we take a more powerful assertion language, and hence a more powerful notion of expressiveness, such a complete axiomatization is possible. the crucial point is that we need to be able to express weakest preconditions of commands with free procedure parameters. the axioms presented here are natural and reflect the syntax of the programming language. such an axiom system provides a tool for understanding how to reason about languages with powerful control features.  joseph y. halpern
the design of an object oriented architecture  this paper proposes a new object model, called the distributed object model, wherein the model is unified as a protection unit, as a method of data abstraction, and as a computational unit, so as to realize reliable, maintainable, and secure systems. an object oriented architecture called zoom is designed based on this object model. a software simulator and cross assembler for this architecture have been implemented. the feasibility and performance of the architecture are discussed according to program sizes and estimated hardware size and execution speed.  yutaka ishikawa mario tokoro
1st workshop on open source software engineering  _open source software (oss) has recently become the focus of considerable interest, yet there remains a need for rigorous analytical inquiry into the subject. this workshop seeks to articulate oss as an se paradigm and to address the requirements of oss in terms of methodology & process, tools & enabling technologies, and human resources & project management. format: round-table discussion. size: maximum 40 participants. position papers required. the workshop report will be published in a special issue of iee proceedings - software on open source software engineering, and workshop participants will be encouraged to submit full research papers based on their position papers for possible inclusion in the special issue._  joseph feller brian fitzgerald andre van der hoek
encapsulators: a new software paradigm in smalltalk-80  certain situations arise in programming that lead to multiply polymorphic expressions, that is, expressions in which several terms may each be of variable type. in such situations, conventional object-oriented programming practice breaks down, leading to code which is not properly modular. this paper describes a simple approach to such problems which preserves all the benefits of good object-oriented programming style in the face of any degree of polymorphism. an example is given in smalltalk-80 syntax, but the technique is relevant to all object-oriented languages.  geoffrey a. pascoe
note on a problem with reed and long's fbr results this short note discusses a problem we found in a recent article in _operating systems review_ [1]. the problem is related to apparent inconsistencies in results presented for a data cache algorithm, known as fbr (frequency based replacement), which we first described in [2]. a property of this algorithm is that cache miss ratios obtained using fbr can be related to lru cache miss ratios for any given trace. application of this property to the results in [1] reveals apparent inconsistencies. these inconsistencies could be the result of errors either in implementing the algorithm or in recording the results. this note also highlights this property of fbr, which should help contribute to its understanding. john t. robinson murthy v. devarakonda
x-ability: a theory of replication  different replication mechanisms provide different solutions to the same basic problem. however, there is no precise specification of the problem itself, only of particular classes of solutions, such as active replication and primary-backup. having a precise specification of the problem would help us better understand the space of possible solutions.  we present a formal definition of the problem solved by replication in the form of a correctness criterion called x-ability (exactly-once ability). an x-able service has obligations to its environment and its clients. it must update its environment under exactly-once semantics. furthermore, it must provide idempotent, non-blocking request processing and deliver consistent results to its clients. x-ability is a local property: replicated services can be specified and implemented independently, and later composed in the implementation of more complex replicated services.  svend frølund rachid guerraoui
an efficient separate compilation strategy for very large programs  this paper describes the design of a compiling system that supports the efficient compilation of very large programs. the system consists of front ends for different languages, a common program database to store the intermediate code, and various back ends, optimizers, debuggers and other development tools. the compiling system achieves efficiency of use by minimizing the number of system components that must be invoked when a small change is made in a program.  a new separate compilation strategy is presented that is both easy and natural to use and does not require language extensions for its use. the database provides the necessary contextual information to support separate compilation and to facilitate complete compile-time checking. also, the use of this database affords a unique opportunity to reduce substantially the cost of recompilation and to support an efficient source patching facility.  andres rudmik barbara g. moore
development cost and size estimation starting from high-level specifications  this paper addresses the problem of estimating cost and development effort of a system, starting from its complete or partial high-level description. in addition, some modifications to evaluate the cost- effectiveness of reusing vhdl-based designs, are presented. the proposed approach has been formalized using an approach similar to the cocomo analysis strategy, enhanced by a project size prediction methodology based on a vhdl function point metric. the proposed design size estimation methodology has been validated through a significant benchmark, the leon-1 microprocessor, whose vhdl description is of public domain  william fornaciari fabio salice umberto bondi edi magini
a framework for reducing the cost of instrumented code  instrumenting code to collect profiling information can cause substantial execution overhead. this overhead makes instrumentation difficult to perform at runtime, often preventing many known _offline_ feedback-directed optimizations from being used in online systems. this paper presents a general framework for performing _instrumentation sampling_ to reduce the overhead of previously expensive instrumentation. the framework is simple and effective, using code-duplication and _counter-based sampling_ to allow switching between instrumented and non- instrumented code.  our framework does not rely on any hardware or operating system support, yet provides a high frequency sample rate that is tunable, allowing the tradeoff between overhead and accuracy to be adjusted easily at runtime. experimental results are presented to validate that our technique can collect accurate profiles (93-98% overlap with a perfect profile) with low overhead (averaging 6% total overhead with a naive implementation). a jalape~ no-specific optimization is also presented that reduces overhead further, resulting in an average total overhead of 3%.  matthew arnold barbara g. ryder
experience with porting techniques on a cobol 74 compiler  the problems of compiler construction have largely been solved for cobol '74, but a remaining fundamental consideration in a commercial environment is the cost of compiler development. this can be reduced by the use of portable software, but the cost of porting to a new system remains significant. in the microprocessor system market, two approaches have been followed. the first is to produce software for a virtual machine environment and simulate this on real hardware be means of an interpreter. most software, including language processors and large parts of the operating system, can be transferred almost unchanged to a new processor. nearly all commercial software for microprocessors has been developed on this basis. the alternative approach is to produce software which, by virtue of certain characteristics, can be made to be portable to new real machine environments, provided the appropriate high level language compiler is available.  we have developed an ans cobol 74 compiler for microprocessors using this second approach [1]. since the compiler compiles cobol at a level approaching level 2 in the main modules to the true machine code of the target machine, the same approach becomes available to the applications programmer. as far as can be established, this work is unique. both compiler and object code interface directly to the machine environment. no interpreter is required for their execution. the compiler system runs on, and generates code for, three machines. in addition, since the compiler is written in a high level language, portable cross compilers are available.  i. m. kipps
implementation benefits of c++ language mechanisms  c + + was designed by bjarne stroustrup at at&amp;t; bell laboratories in the early 1980s as an extension to the c language, providing data abstraction and object-oriented programming facilities. c + + provides a natural syntactic extension to c, incorporating the class construct from simula. a design principle was to remain compatible and comparable with c in terms of syntax, performance and portability another goal was to define an object-oriented language that significantly increased the amount of static type checking provided, with user-defined types (classes) and built-in types being part of a single unified type system obeying identical scope, allocation and naming rules. these aims have been achieved, providing some underlying reasons why c + + has become so prevalent in the industry. the approach has allowed a straightforward evolution from existing c-based applications to the new facilities offered by c + + , providing an easy transition for both software systems and programmers. the facilities described are based on release 2.0 of the language, the version on which the ansi and is0 standardization of c + + is being based.  david jordan
the persistent store as an enabling technology for integrated project support environments  the software engineering community has recognised the need for integrated project support environments (ipses) for some time. the technique of integration as a method of cost saving applies to all levels in the hierarchy of problem solving, both hardware and software. this paper discusses one such level, that in which the ipse is implemented and in particular the use of a persistent store as an enabling technology for ipses.  the facilities of the language ps-algol necessary to support an ipse are illustrated by example and it is demonstrated how an ipse's base may be provided by a persistent store that supports first class procedures as data objects. the need for a type secure object system which allows static and dynamic binding is demonstrated and finally the secure transactional base of ps-algol is shown to be a necessary and sufficient condition to provide secure version control and concurrent access to both programs and data.  ronald morrison alan dearle peter j. bailey alfred l. brown malcolm p. atkinson
perturbation analysis of high level instrumentation for spmd programs  the process of instrumenting a program to study its behavior can lead to perturbations in the program's execution. these perturbations can become severe for large parallel systems or problem sizes, even when one captures only high level events. in this paper, we address the important issue of eliminating execution perturbations caused by high-level instrumentation of spmd programs. we will describe perturbation analysis techniques for common computation and communication measurements, and show examples which demonstrate the effectiveness of these techniques in practice.  sekhar r. sarukkai allen d. malony
introduction to the attribute driven design method  this tutorial will introduce the attribute driven design (add) method. add is a method for designing the software architecture of a system or collection of systems based on an explicit articulation of the quality attribute goals for the system(s). the method is appropriate for any quality attributes but has been particularly elaborated for the attributes of performance, modifiability, security, reliability/availability and usability. the method has been used for designing the software architecture of products ranging from embedded to information systems.  felia buchmann len bass