waashk/acm huggingface dataset:
the state of reuse: perceptions of the reuse community the ninth workshop on institutionalizing software reuse (wisr9) was held january 7-9, 1999, bringing together established reuse researchers from academia and industry. on the first day of the workshop, a survey was taken to collect feedback about the reuse community's collective beliefs and disagreements. preliminary results were then shared with the participants during the last plenary session of the workshop. this article presents the results of the survey, which capture the opinions of an important segment of the reuse community. stephen h. edwards
supporting software reuse within an integrated software development environment (position paper)  significant gains in programmer productivity have been achieved through the use of simple abstraction mechanisms that enhance the reuse of code. there are other useful forms of abstraction (over arbitrary identifier bindings, for example) which could further increase reuse rates, but are not well supported by programming languages; such forms may be better expressed by exploiting mechanisms provided by an integrated programming environment. this paper outlines ongoing work which aims to provide programming environment mechanisms that support the reuse of code via various forms of abstraction that complement those traditionally provided by programming languages. the concept of derivation- based reuse is also defined, and a generic framework for its support is outlined. in addition, a collection of environment mechanisms, intended to fit within this framework, are outlined.  keith j. ransom chris d. marlin
the java syntactic extender (jse) the ability to extend a language with new syntactic forms is a powerful tool. a sufficiently flexible macro system allows programmers to build from a common base towards a language designed specifically for their problem domain. however, macro facilities that are integrated, capable, and at the same time simple enough to be widely used have been limited to the lisp family of languages to date. in this paper we introduce a macro facility, called the java syntactic extender (jse), with the superior power and ease of use of lisp macro sytems, but for java, a language with a more conventional algebraic syntax. the design is based on the dylan macro system, but exploits java's compilation model to offer a full procedural macro engine. in other words, syntax expanders may be implemented in, and so use all the facilities of, the full java language jonthan bachrach keith playford
producer: a tool for translating smalltalk-80 to objective-c  source to source translation tools provide a way of integrating the strengths of production programming environments like c/unix with rapid prototyping environments like smalltalk-80 into a comprehensive hybrid environment that spans more of the software development life-spiral than ever before. this paper describes a tool-assisted process for translating smalltalk-80 programs into objective-c , and shows how the tool, called producer, is used in practice. to assist others in using this translation tool, we have made producer publicly available without charge on usenet.  brad j. cox kurt j. schmucker
the pan language-based editing system for integrated development  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.  robert a. ballance susan l. graham michael l. vande vanter
a study of the prather software metric (abstract)  due to the increasing complexity of modern software code, we need ways of effectively measuring the difficulty of programs to detect problem code during development. program metrics [conte, 86] are a partial answer to this need. they offer us various ways of measuring the length, modularity, nesting, and data flow of software.  the prather metric, developed by ronald e. prather [prather, 84], is a statement structure metric which measures statement nesting and control structures as a function of the simple statements they contain. for our research, we developed a program2 which takes pascal programs as input and returns the prather measures of the programs.  our project was to examine the prather metric by comparing it with the statement count and mccabe measures, both are commonly used metrics, and see if there was a relationship between prather and the other measures. if there is a correlation, this would show that prather is not truly a unique measure, but it contains aspects of statement count or mccabe's measure.  we also examined the use of the prather metric as a cheating checker on student programs. we found that prather may be better at picking out possible cheaters than statement count and mccabe's measure. we concluded that this was due to the nature of the prather metric: it includes aspects of statement count and number of paths plus a measure of nesting.  scott moore ronald curtis
a rendezvous with linda the ada 9x revision found the rendezvous mechanism too complex to implement as the communication mechanism in a distributed system. in this paper another distributed programming model, linda, is related to the rendezvous mechanism. linda can be used to allow tasks to communicate in a rendezvous like manner. sequences of linda operations that roughly corresponds to different rendezvous operations are given and a small extension of linda is presented in order to handle more of the rendezvous constructs. linda can be used to communicate across partitions as well as within partitions. kristina lundqvist göran wall
algorithmic modifications to the jacobi-davidson parallel eigensolver to dynamically balance external cpu and memory load  clusters of workstations (cows) and smps have become popular and cost effective means of solving scientific problems. because such environments may be heterogenous and/or time shared, dynamic load balancing is central to achieving high performance. our thesis is that new levels of sophistication are required in parallel algorithm design and in the interaction of the algorithms with the runtime system. to support this thesis, we illustrate a novel approach for application-level balancing of external cpu and memory load on parallel iterative methods that employ some form of local preconditioning on each node. there are two key ideas. first, because all nodes need not perform their portion of the preconditioning phase to the same accuracy, the code can achieve perfect loadbalance, dynamically adapting to external cpu load, if we stop the preconditioning phase on all processors after a fixed amount of time. second, if the program detects memory thrashing on a node, it recedes its preconditioning phase from that node, hopefully speeding the completion of competing jobs hence the relinquishing of their resources. we have implemented our load balancing approach in a state-of-the-art, coarse grain parallel jacobi-davidson eigensolver. experimental results show that the new method adapts its algorithm based on runtime system information, without compromising the overall convergence behavior. we demonstrate the effectiveness of the new algorithm in a cow environment under (a) variable cpu load and (b) variable memory availability caused by competing applications.  richard tran mills andreas stathopoulos evgenia smirni
the philosophy of lisp  we consider here the importance of an overall systems viewpoint in avoiding computer-related risks. according to webster's, a system is a regularly interacting or interdependent group of items forming a unified whole. in computer systems, one person's components may be another person's system, and one person's system may in turn be one of another person's components. that is, each layer of abstraction may have it own concept of a system. we speak of a memory system, a multiprocessor system, a distributed system, a multisystem system, a networked system, and so on. a system design can most effectively be considered as a unified whole when it is possible to analyze the interdependent subsystems individually and then to evaluate, reason about, and test the behavior of the entire system based on the interactions among the subsystems. this is particularly true of distributed systems that mask the presence of distributed storage, processing, and control. at each layer of abstraction, it is desirable to design (sub)systems that are context-free, but in reality there may be subtle interactions that must be accommodated--- particularly those involving the operating environment.  kenneth h. sinclair david a. moon
deterministic execution testing of concurrent ada programs  an execution of a concurrent program p exercises a sequence of synchronization events, called a synchronization sequence or a syn-sequence. this non- deterministic execution behavior creates a problem during the testing phase of p: when testing p with input x, a single execution is insufficient to determine the correctness of p with input x.  in this paper, we show how to accomplish deterministic execution testing of a concurrent ada program according to a given syn-sequence. we first define the format of a syn-sequence which provides sufficient information for deterministic execution. then we show how to transform a concurrent ada program p into a slightly different program p* (also written in ada) so that an execution of p* with (x,s) as input, where x and s are an input and syn- sequence of p respectively, determines whether or not s is feasible for p with input x and produces the same result as p with input x and syn-sequence s would, provided that s is feasible. tools for transforming concurrent ada programs for deterministic execution testing are described.  r. carver k. c. tai
which pointer analysis should i use?  during the past two decades many different pointer analysis algorithms have been published. although some descriptions include measurements of the effectiveness of the algorithm, qualitative comparisons among algorithms are difficult because of varying infrastructure, benchmarks, and performance metrics. without such comparisons it is not only difficult for an implementor to determine which pointer analysis is appropriate for their application, but also for a researcher to know which algorithms should be used as a basis for future advances.  this paper describes an empirical comparison of the effectiveness of five pointer analysis algorithms on c programs. the algorithms vary in their use of control flow information (flow-sensitivity) and alias data structure, resulting in worst-case complexity from linear to polynomial. the effectiveness of the analyses is quantified in terms of compile-time precision and efficiency. in addition to measuring the direct effects of pointer analysis, precision is also reported by determining how the information computed by the five pointer analyses affects typical client analyses of pointer information: mod/ref analysis, live variable analysis and dead assignment identification, reaching definitions analysis, dependence analysis, and conditional constant propagation and unreachable code identification. efficiency is reported by measuring analysis time and memory consumption of the pointer analyses and their clients.  michael hind anthony pioli
preliminary design use cases: combining use cases and event response lists for reuse and legacy system enhancement this report describes an approach to combining use cases with elements from event response lists to help improve requirements understanding. the format suggested for the combination, called the _preliminary design use cas,_ proves particularly effective in facilitating reuse of existing system elements. it also supports the definition of extensions to existing systems, and encourages dialogue between customers, analysts and designers. the approach has resulted from industrial practice and has proven particularly successful. declan martin
pgraphite: an experiment in persistent typed object management  defining, creating, and manipulating persistent typed objects will be central activities in future software environments. pgraphite is a working prototype through which we are exploring the requirements for the persistent object capability of an object management system in the arcadia software environment.  pgraphite represents both a set of abstractions that define a model for dealing with persistent objects in an environment and a set of implementation strategies for realizing that model. pgraphite currently provides a type definition mechanism for one important class of types, namely directed graphs, and the automatic generation of ada implementations for the defined types, including their persistence capabilities.  we present pgraphite, describe and motivate its model of persistence, outline the implementation strategies that it embodies, and discuss some of our experience with the current version of the system.  jack c. wileden alexander l. wolf charles d. fisher peri l. tarr
a presentation manager based on application semantics  we describe a system for associating the user interface entities of an application with their underlying semantic objects. the associations are classified by arranging the user interface entities in a type lattice in an object-oriented fashion. the interactive behavior of the application is described by defining application operations in terms of methods on the types in the type lattice. this scheme replaces the usual "active region" interaction model, and allows application interfaces to be specified directly in terms of the objects of the application itself. we discuss the benefits of this system and some of the difficulties we encountered.  s. mckay w. york m. mcmahon
effective whole-program analysis in the presence of pointers understanding large software systems is difficult. traditionally, automated tools are used to assist program understanding. however, the representations constructed by these tools often require prohibitive time and space. demand-driven techniques can be used to reduce these requirements. however, the use of pointers in modern languages introduces additional problems that do not integrate well with these techniques. we present new techniques for effectively coping with pointers in large software systems written in the c programming language and use our techniques to implement a program slicing tool.first, we use a fast, flow-insensitive, points-to analysis before traditional data-flow analysis. second, we allow the user to parameterize the points-to analysis so that the resulting program slices more closely match the actual program behavior. such information cannot easily be obtained by the tool or might otherwise be deemed unsafe. finally, we present data-flow equations for dealing with pointers to local variables in recursive programs. these equations allow the user to select an arbitrary amount of calling context in order to better trade performance for precision.to validate our techniques, we present empirical results using our program slicer on large programs. the results indicate that cost-effective analysis of large programs with pointers is feasible using our techniques. darren c. atkinson william g. griswold
persistent shared object support in the guide system: evaluation & related work  the purpose of the guide project is to explore the use of shared objects for communication in a distributed system, especially for applications that require cooperative work. since 1986, two prototypes have been implemented respectively on top of unix (guide-1) and mach 3.0 (guide-2). they have been used for the development of distributed cooperative applications, allowing us to validate or reject many design choices in the system.  this paper gathers the lessons learned from our experience and compares the basic design choices with those in other distributed object-oriented systems. the lessons may be summarized as follows. this system layer must provide a generic interface for the support of several object-oriented languages. it must manage fine grained objects and enforce protection between objects and processes. these requirements can be achieved with an acceptable trade-off between protection and efficiency.  daniel hagimont p.-y. chevalier a. freyssinet s. krakowiak s. lacourte j. mossière x. rousset de pina
the design of a data flow analyzer  this paper presents an efficient inter-procedural data flow analysis algorithm for precisely determining aliases in programs that employ a rich set of parameter passing mechanisms and pointer data types. this approach handles the use of pointers bounded to a data type as in pascal, as well as unbounded pointers that can point to the same locations to which variables map. in the last step of this approach, the alias information is used to compute data flow information that is required for optimization.  anita l. chow andres rudmik
effective fine-grain synchronization for automatically parallelized programs using optimistic synchronization primitives  this article presents our experience using optimistic synchronization to implement fine-grain atomic operations in the context of a parallelizing compiler for irregular, object- based computations. our experience shows that the synchronization requirements of these programs differ significantly from those of traditional parallel computations, which use loop nests to access dense matrices using affine access functions. in addition to coarse-grain barrier synchronization, our irregular computations require synchronization primitives that support efficient fine-grain atomic operations. the standard implementation mechanism for atomic operations uses mutual exclusion locks. but the overhead of acquiring and releasing locks can reduce the performance. locks can also consume significant amounts of memory. optimistic synchronization primitives such as loud-linked/store conditional are an attractive alternative. they require no additional memory and eliminate the use of heavyweight blocking synchronization constructs. we evaluate the effectiveness of optimistic synchronization by comparing experimental results from two versions of a parallelizing compiler for irregular, object-based computations. one version generates code that uses mutual exclusion locks to make operations execute atomically. the other version generates code that uses mutual exclusion locks to make operations execute atomically. the other version uses optimistic synchronization. we used this compiler to automatically parallelize three irregular, object-based benchmark applications of interest to the scientific and engineering computation community. the presented experimental results indicate that the use of optimistic synchronization in this context can significantly reduce the memory consumption and improve the overall performance.  martin c. rinard
an apl/370 compiler and some performance comparisons with apl interpreter and fortran  the experimental apl/370 e-compiler compiles a subset of apl which is large enough for most scientific and engineering uses, directly into 370 assembly code. the compiler does not require variable declarations. the front-end employs extensive type-shape analysis based on global dataflow analysis. the back-end takes the parse trees, graphs and tables produced by the front-end and generates 370-code which runs independently of the interpreter. the compiled-code executes at 2-10 times the speed of the interpreter on several one-line functions, and this ratio increases significantly with iterative programs. the code quality is comparable to that produced by an optimizing fortran compiler on fortran programs corresponding to our test cases. this removes the performance penalty of apl in computation intensive applications.  wai-mee ching
evaluation of processor code efficiency for embedded systems  this paper evaluates the code efficiency of the arm, java, and x86 instruction sets by compiling the spec cpu95/ cpu2000/jvm98 and caffeinemark benchmarks, in terms of code sizes, basic block sizes, instruction distributions, and average instruction lengths.  as a result, mainly because (i) the java architecture is a stack machine, (ii) there are only four local variables which can be accessed by a 1-byte instruction, and (iii) additional instructions are provided for the network security, the code efficiency of java turns out to be inferior to that of arm thumb. moreover, through this efficiency analysis it should be claimed that a more efficient code architecture can be constructed by taking minute account of the customization of an instruction set as well as the number of registers.  morgan hirosuke miki mamoru sakamoto shingo miyamoto yoshinori takeuchi toyohiko yoshida isao shirakawa
a foundation for an efficient multi-threaded scheme system  we have built a parallel dialect of scheme called sting that differs from its contemporaries in a number of important respects. sting is intended to be used as an operating system substrate for modern parallel programming languages.  the basic concurrency management objects is sting are first-class lightweight threads of control and virtual processors (vps). unlike high-level concurrency structures, sting threads and vps are not encumbered by complex synchronization protocols. threads and vps are manipualted in the same way as any other scheme structure.  sting separates thread policy decisions from thread implementation ones. implementations of different parallel languages built on top of sting can define their own scheduling and migration policies without requiring modification to the runtime system or the provided interface. process migration and scheduling can be customized by applications on a per-vp basis.  the semantics and implementation of threads minimizes the cost of thread creation, and puts a premium on storage locality. the storage management policies in sting lead to better cache and page utilization, and allows users to experiment with a variety of different execution regimes---from fully delayed to completely eager evaluation.  suresh jagannathan jim philbin
on the notion of inheritance  one of the most intriguing---and at the same time most problematic---notions in object-oriented programing is inheritance. inheritance is commonly regarded as the feature that distinguishes object-oriented programming from other modern programming paradigms, but researchers rarely agree on its meaning and usage. yet inheritance of often hailed as a solution to many problems hampering software development, and many of the alleged benefits of object- oriented programming, such as improved conceptual modeling and reusability, are largely credited to it. this article aims at a comprehensive understanding of inheritance, examining its usage, surveying its varieties, and presenting a simple taxonomy of mechanisms that can be seen as underlying different inheritance models.  antero taivalsaari