waashk/acm huggingface dataset:
tcolada and the "middle end" of the pqcc ada compiler  a compiler is traditionally partitioned into a (mostly) machine independent front end which performs lexical, syntactic, and semantic analysis, and a machine dependent back end which performs optimization and code generation. in the ada compiler being implemented at carnegie-mellon university in the pqcc project, it is useful to identify a set of phases occurring at the start of the back end - i.e., "middle end" \- after semantic analysis but before optimization. these phases, known collectively as "cwvm" (an abbreviation for "compiler writer's virtual machine") make basic representational choices and reflect these in an expanded program tree. this paper describes both tcolada \\- the intermediate language interface produced by the front end - and the phases comprising cwvm. tcolada is a graph structured high level representation of the source program which includes both the symbol table and the program tree. the cwvm phases perform transformations of the tcolada graph which fall into three categories: language oriented (e.g., expansion of checking for constructs such as array indexing), virtual machine oriented (e.g., translation of up-level addressing into "display" vector accesses), and actual machine oriented (e.g., expansion of component selection into address arithmetic).  benjamin m. brosgol
parallel searching for binary cartesian product files  the problem of distributing buckets in a file among m disks to facilitate parallel searching for a set of queries is analysed in this paper. we are particularly concerned with the file distribution problem for binary cartesian product files, and partial match queries. a method is proposed and shown to be strict optimal under certain conditions. the performance of the proposed method is compared with those of an "ideal" strict optimal and du's heuristic allocation method.  yuan y. sung
viewing object as patterns of communicating agents  following our own experience developing a concurrent object-oriented language as well of that of other researchers, we have identified several key problems in the design of a concurrency model compatible with the mechanisms of object- oriented programming. we propose an approach to language design in which an executable notation describing the behaviour of communicating agents is extended by syntactic patterns that encapsulate language constructs. we indicate how various language models can be accommodated, and how mechanisms such as inheritance can be modeled. finally, we introduce a new notion of types that characterizes concurrent objects in terms of their externally visible behaviour.  oscar nierstrasz michael papathomas
using symbolic execution for verifying safety-critical systems safety critical systems require to be highly reliable and thus special care is taken when verifying them in order to increase the confidence in their behavior. this paper addresses the problem of formal verification of safety critical systems by providing empirical evidence of the practical applicability of symbolic execution and of its usefulness for checking safety-related properties. in this paper, symbolic execution is used for building an operational model of the software on which safety properties, expressed by means of a path description language (pdl), can be assessed. alberto coen-porisini giovanni denaro carlo ghezzi mauro pezze
configuration editing, generation and test within working contexts  in a software development environment any progress is reflected in modifications of design documents. these changes must be attended by recording of versions in order to restore consistent states and to rebuild delivered systems for error detection. the introduction of versions implies the need for version selection mechanisms, to achieve the same degree of operability as known in versionless environments.  this paper introduces a version selection mechanism based on the notion of working contexts. examples generated by the add document management system illustrate how editing, generation and test of configurations are eased using working contexts.  hans-ulrich kobialka
an organized, devoted, project-wide reuse effort  many projects have struggled with attempting reuse; however, both size and complexity of a large project create additional obstacles that can minimize the potential for software reuse. therefore, successful software reuse can not be guaranteed solely by the use of ada, object-oriented development methods, taxonomies, storage and retrieval systems, commercial libraries, software methods, standards, or configuration management systems! it was proposed [bowen, 1990], that inorder for software reuse to succeed on large projects, these methods and techniques must be combined in a coordinated reuse effort. the software process must address issues related to the management of the development effort, in addition to addressing purely technical issues. this paper will present how th e concept of an organized, devoted, project- wide reuse effort has been practically applied by computer sciences corporation (csc), over the past year on the advanced automation system (aas), as part of the team led by international business machines (ibm) corporation.  gregory m. bowen
experiments with computer software complexity and reliability  experiments with quantitative assessment and prediction of software reliability are presented. the experiments are based on the analysis of the error and the complexity characteristics of a large set of programs. the first part of the study concerns the data collection process and the analysis of the error data and complexity measures. the relationships between the complexity profile and the error data of the procedures of the programs are then investigated with the help of discriminant statistical analysis technique. the results of these analyses show that an estimation can be derived from the analysis of its complexity profile.  d. potier j. l. albin r. ferreol a. bilodeau
evaluating software engineering methods and tools: part 9: quantitative case study methodology this article is the first of three articles describing how to undertake a quantitative case study based on work done as part of the desmet project [1], [2]. in the context of methods and tool evaluations, case studies are a means of evaluating methods and tools as part of the normal software development activities undertaken by an organisation. the main benefit of such case studies is that they allow the effect of new methods and tools to be assessed in realistic situations. thus, case studies provide a cost-effective means of ensuring that process changes provide the desired results. however, unlike formal experiments and surveys, case studies do not have a well-understood theoretical basis. this series of articles provides guidelines for organising and analysing case studies so that your investigations of new technologies will produce meaningful results. barbara ann kitchenham lesley m. pickard
efficient shared memory with minimal hardware support shared memory is widely regarded as a more intuitive model than message passing for the development of parallel programs. a shared memory model can be provided by hardware, software, or some combination of both. one of the most important problems to be solved in shared memory environments is that of cache coherence. experience indicates, unsurprisingly, that hardware-coherent multiprocessors greatly outperform distributed shared-memory (dsm) emulations on message-passing hardware. intermediate options, however, have received considerably less attention. we argue in this position paper that one such option---a multiprocessor or network that provides a global physical address space in which processors can make non-coherent accesses to remote memory without trapping into the kernel or interrupting remote processors---can provide most of the performance of hardware cache coherence at little more monetary or design cost than traditional dsm systems. to support this claim we have developed the _cashmere_ family of software coherence protocols for ncc-numa (non-cache-coherent, non-uniform-memory access) systems, and have used execution-driven simulation to compare the performance of these protocols to that of full hardware coherence and distributed shared memory emulation. we have found that for a large class of applications the performance of ncc-numa multiprocessors rivals that of fully hardware-coherent designs, and significantly surpasses the performance realized on more traditional dsm systems. leonidas i. kontothanassis michael l. scott
compositional parallel programming languages  in task-parallel programs, diversee activities can take place concurrently, and communication and synchronization patterns are complex and not easily predictable. previous work has identified compositionality as an important design principle for task-parallel programs. in this article, we discuss alternative approaches to the realization of this principle, which holds that properties of program components should be preserved when those co ponents are composed in parallel with other program components. we review two programming languages, strand and program composition notation, that support compositionality via a small number of simple concepts, namely, monotone operations on shared opbects, a uniform addressing mechanism, and parallel composition. both languages have been used extensively for large-scale application development, allowing us to provide an informed assessment of both their strengths and their weaknesses. we observe that while compositionality simplifies development of complex applications, the use of specialized languages hinders reuse of existing code and tools and the specification of domain decomposition strategies. this suggests an alternative approach based on small extensions to existing sequential languages. we conclude the article with a discussion of two languages that realized this strategy.  ian foster
related field analysis  we present an extension of field analysis (sec [4]) called _related field analysis_ which is a general technique for proving relationships between two or more fields of an object. we demonstrate the feasibility and applicability of related field analysis by applying it to the problem of removing array bounds checks. for array bounds check removal, we define a pair of related fields to be an integer field and an array field for which the integer field has a known relationship to the length of the array. this related field information can then be used to remove array bounds checks from accesses to the array field. our results show that related field analysis can remove an average of 50% of the dynamic array bounds checks on a wide range of applications.  we describe the implementation of related field analysis in the swift optimizing compiler for java, as well as the optimizations that exploit the results of related field analysis.  aneesh aggarwal keith h. randall
melding data flow and object-oriented programming  meld combines concepts from data flow and object-oriented programming languages in a unique approach to tool reusability. meld provides three units of abstraction --- equations, classes and features --- that together allow sufficient options for granularity and encapsulation to support the implementation of reusable tools and the composition of existing tools in parallel (i.e., interleaved) as well as in series.  gail e. kaiser david garlan
a new notion of encapsulation  generally speaking, a "module" is used as an "encapsulation mechanism" to tie together a set of declarations of variables and operations upon them. although there is no standard way to instantiate or use a module, the general idea is that a module describes the implementation of all the values of a given type. we believe that this is too inflexible to provide enough control:  one should be able to use different implementations (given by different modules) for variables (and values) of the same type.  when incorporated properly into the notation, this finer grain of control allows one to program at a high level of abstraction and then to indicate how various pieces of the program should be implemented. it provides simple, effective access to earlier-written modules, so that they are useable in a more flexible manner than is possible in current notations. it generalizes to provide the ability to indicate structural transformations, in a disciplined fashion, in order to achieve efficiency with respect to time or space. however, the program will still be understood at the abstract level and the transformations or implementations will be looked at only to deal with efficiency concerns. finally, some so-called "data types" (e.g. stack and subranges of the integers) can more properly be looked upon simply as restricted implementations of more general types (e.g. sequence and integer). thus, the notion of subtype becomes less important.  david gries jan prins
consistency checking for multiple view software architectures  consistency is a major issue that must be properly addressed when considering multiple view architectures. in this paper, we provide a formal definition of views expressed graphically using diagrams with multiplicities and propose a simple algorithm to check the consistency of diagrams. we also put forward a simple language of constraints to express more precise (intra- view and inter- view) consistency requirements. we sketch a complete decision procedure to decide whether diagrams satisfy a given constraint expressed in this language. our framework is illustrated with excerpts of a case study: the specification of the architecture of a train control system.  pascal fradet daniel le metayer michael perin
exploring issues of operating systems structuring: from microkernel to extensible systems the microkernel concept has once been the most advocated approach for operating system development. unfortunately, before its publicized advantages have been fully realized in an operating system implementation, current operating system researchers claim its weaknesses and make their ways to develop "extensible" operating systems. new operating systems like spin, ageis, cache kernel, apertos and scout, employ new concepts to support application specific customization and optimal allocation of system resource, in order to boost up the performance of certain applications. the microkernel concept in itself never contradicts with this purpose, as it is to provide basic efficient primitives for construction of system services. probably, the crucial problem is that the os architecture of most current microkernel implementations cannot suitably meet with the new requirements of extensibility. in this paper, we try to explore issues in developing a better os architecture that can fully enhance os extensibility. moreover, we investigate how microkernel abstraction can be remodeled to support better reconfiguration in operating systems. to cope with the conflicting issues of efficiency, flexibility and ease of reconfiguration, we suggest and discuss an approach of structuring operating systems. the approach is characteristed by lightweight meta-abstraction mechanism and progressive reflective reconfiguration. w. h. cheung anthony h. s. loong
efficient context-sensitive pointer analysis for c programs  this paper proposes an efficient technique for context-sensitive pointer analysis that is applicable to real c programs. for efficiency, we summarize the effects of procedures using partial transfer functions. a partial transfer function (ptf) describes the behavior of a procedure assuming that certain alias relationships hold when it is called. we can reuse a ptf in many calling contexts as long as the aliases among the inputs to the procedure are the same. our empirical results demonstrate that this technique is successful---a single ptf per procedure is usually sufficient to obtain completely context- sensitive results. because many c programs use features such as type casts and pointer arithmetic to circumvent the high-level type system, our algorithm is based on a low-level representation of memory locations that safely handles all the features of c. we have implemented our algorithm in the suif compiler system and we show that it runs efficiently for a set of c benchmarks.  robert p. wilson monica s. lam
generics and verification in ada  this paper explores the restrictions a mechanism in the style of the ada generics facility would have to satisfy in order to be amenable to existing verification techniques. "generic verification" is defined and defended as the appropriate goal for any such facility. criteria are developed for generic verification to be possible and then ada is evaluated with respect to these criteria. an example of the application of these techniques to an ada unit is presented to show that generic verification is possible at least on a subclass of ada generic units. finally some potential applications of verified generic units are presented.  william d. young donald i. good
the specification and testing of quantified progress properties in distributed systems  _there are two basic parts to the behavioral specification of distributed systems: safety and progress. in earlier work, we developed a tool to monitor progress properties of corba components specified using the temporal operator_ transient. _in this paper, we address the specification and testing of transient properties that are quantified (over both bounded and unbounded domains)._  _we categorize typical quantifications that arise in practical systems and discuss possible implementation strategies. we define functional transience, a subclass of quantified transient properties that can be monitored in constant space and time. we outline the design and implementation of a tool for testing these properties in corba components._  prakash krishnamurthy paolo a. g. sivilotti
load distribution and balancing support in a workstation-based distributed system in distributed systems, load distribution and balancing are primary functions addressed to improvements on system performance and additional user comfort. incoming task allocation and remote process execution are main responsibilities of a well designed system to achieve such performance improvements. both aspects involve a number of non trivial tasks.as a basement for further automatic system decision in a distributed environment, this paper propose a user-supervised processor allocation scheduler, shows which information should be collected and when and how to collect and disseminate it to support the user decision.the main problems to be considered when implementing remote process execution are discussed and a design for an alternative system attempting to solve these problems is also shown. d. arredondo m. errecalde f. piccoli m. printista r. gallard s. flores
public case-base and tool kit using a validated rrm software systems are important, yet poorly understood entities. users, and at times even developers, do not always understand what is occurring within the software in use. the exploratory visualization project attempts to address the technical issues involved in helping users understand running computations, especially long-lived distributed computations. the three facets of this problem that we investigate in our project are 1) creating accurate views of a running execution, 2) providing comprehensive and efficient access to a computation, and 3) responding to the user's interactions to promote understanding and optimize data collection. d. rine n. nada
supporting the process of satisfying information needs with reusable software libraries: an empirical study  retrieval tools for component-based software reuse libraries face two interrelated problems. the first is the ill- defined nature of information needs. the second is that large repositories will often use unfamiliar and esoteric vocabulary to describe software components. codefinder, a retrieval system designed to help developers locate software components for reuse, addresses these issues through an innovative combination of retrieval by reformulation and spreading activation. an empirical study comparing codefinder with two other systems showed evidence that subjects using codefinder with ill-defined tasks or mismatching vocabulary performed better than subjects using the other systems. the study confirmed the utility of spreading activation and retrieval by reformulation techniques for satisfying information needs of the kind encountered in software design.  scott henninger
the implementation of set functions in apl: a proposal this paper has been translated from "l'implantation de fonctions pour les ensembles en apl (une proposition)" (_les nouvelles d'apl,_ no. 22, mars 1997, pp. 81-86).proposals are formulated for the implementation of the primitive set functions: unique, union, intersection, and difference. user-defined functions are given, simulating those proposed primitive functions, illustrated with some examples.in a note added to a letter to the editor, published in _les nouvelles d'apl_ [1], it emphasizes the need to extend apl with primitive functions for handling sets. definitions are proposed in this paper for such primitives: the monadic function unique and the dyadic functions union, intersection, and difference. user defined functions are given which are equivalent to those proposed primitives, illustrated with some examples. concepts are based on those described by d. livingstone and by the authors referenced in his paper [2]. the number of occurrences of the items in the results are adapted to the needs imposed by handling relational database algebra [2]. joseph de kerf
structural specification-based testing: automated support and experimental evaluation  in this paper, we describe a testing technique, called structural specification-based testing (sst), which utilizes the formal specification of a program unit as the basis for test selection and test coverage measurement. we also describe an automated testing tool, called adlscope, which supports sst for program units specified in sun microsystems' assertion definition language (adl). adlscope automatically generates coverage conditions from a program's adl specification. while the program is tested, adlscope determines which of these conditions are covered by the tests. an uncovered condition exhibits aspects of the specification inadequately exercised during testing. the tester uses this information to develop new test data to exercise the uncovered conditions.  we provide an overview of sst's specification- based test criteria and describe the design and implementation of adlscope. specification-based testing is guided by a specification, whereby the testing activity is directly related to what a component under test is supposed to do, rather than what it actually does. specification-based testing is a significant advance in testing, because it is often more straightforward to accomplish and it can reveal failures that are often missed by traditional code-based testing techniques. as an initial evaluation of the capabilities of specification- based testing, we conducted an experiment to measure defect detection capabilities, code coverage and usability of sst/adlscope; we report here on the results.  juei chang debra j. richardson
a laboratory for teaching object oriented thinking  it is difficult to introduce both novice and experienced procedural programmers to the anthropomorphic perspective necessary for object-oriented design. we introduce crc cards, which characterize objects by class name, responsibilities, and collaborators, as a way of giving learners a direct experience of objects. we have found this approach successful in teaching novice programmers the concepts of objects, and in introducing experienced programmers to complicated existing designs.  k. beck w. cunningham