waashk/acm huggingface dataset:
violatility analysis framework for product lines  evolution of a software intensive system is unavoidable. in fact, evolution can be seen as a part of reuse process. during the evolution of the software asset, the major part of the system functionality is normally reused. so the key issue is to identify the volatile parts of the domain requirements. additionally, there is promise that tailored tool support may help supporting evolution in software intensive systems. in this paper, we describe the volatility analysis method for product lines. this highly practical method has been used in multiple domains and is able to express and estimate common types of evolutional characteristics. the method is able to represent volatility in multiple levels and has capacity to tie the volatility estimation to one product line member specification. we also briefly describe current tool support for the method. the main contribution of this paper is a volatility analysis framework that can be used to describe how requirements are estimated to evolve in the future. the method is based on the definition hierarchy framework.  juha savolainen juha kuusela
the derivation of microcode by symbolic execution  given a description of a computer called the "target" and a micro processor called the "host" we would like to generate a micro program which when executed by the host will simulate the target. we accomplish this by first breaking the target down into a set of small segments. then, logical conditions for an appropriate microcode are generated for each segment by a combination of symbolic execution and simplification. when completed, the segments are assembled into a working code by solving the set of logical conditions.  john wade ulrich
the design, implementation, and evaluation of jade  jade is a portable, implicitly parallel language designed for exploiting task- level concurrency.jade programmers start with a program written in a standard serial, imperative language, then use jade constructs to declare how parts of the program access data. the jade implementation uses this data access information to automatically extract the concurrency and map the application onto the machine at hand. the resulting parallel execution preserves the semantics of the original serial program. we have implemented jade as an extension to c, and jade implementations exist for s hared-memory multiprocessors, homogeneous message-passing machines, and heterogeneous networks of workstations. in this atricle we discuss the design goals and decisions that determined the final form of jade and present an overview of the jade implementation. we also present our experience using jade to implement several complete scientific and engineering applications. we use this experience to evaluate how the different jade language features were used in practice and how well jade as a whole supports the process of developing parallel applications. we find that the basic idea of preserving the serial semantics simplifies the program development process, and that the concept of using data access specifications to guide the parallelization offers significant advantages over more traditional control-based approaches. we also find that the jade data model can interact poorly with concurrency patterns that write disjoint pieces of a single aggregate data structure, although this problem arises in only one of the applications.  martin c. rinard monica s. lam
augmentation of object-oriented programming by concepts of abstract data type theory: the modpascal experience  object-oriented programming and abstract data type (adt) theory have emerged from the same origin of computer science: the inability to deal efficiently with 'programming in the large' during the early seventies. each of the approaches has led to significant practical and theoretical results resp. nevertheless it is still unsatisfactory that up to now the mutual influence seems to be limited to more or less syntactical issues (e.g. the provision of packages, clusters, forms).  in this paper we report on the object-oriented language modpascal that was developed as part of the integrated software development and verification (isdv) project. we show how the essence of concepts of adt theory as algebraic specifications, enrichments, parameterized specifications or signature morphisms as well as their semantics can be consistently integrated in an imperative object-oriented language. furthermore, as the experience of using modpascal as target language of the isdv system has shown, we claim that without similar support of theoretical concepts techniques like formal specification of programs or algebraic verification loose their power and even applicability.  walter g. olthoff
the revival transformation  the notion that a definition of a variable is dead is used by optimizing compilers to delete code whose execution is useless. we extend the notion of deadness to that of partial deadness, and define a transformation, the revival transformation, which eliminates useless executions of a (partially dead) definition by tightening its execution conditions without changing the set of uses which it reaches or the conditions under which it reaches each of them.  lawrence feigen david klappholz robert casazza xing xue
the consequences of one's first programming language  who has not seen programs written in one programming language that have the style of another language? having experienced "fortran with semicolons" and "c with a basic flavor" over the years, it occurred to me to wonder whether the programmer's first programming language had an effect on programming ability as profound as the effect of one's native language on one's thought patterns.  over many years of programming, teaching programming, and debugging other people's programs, it seemed to me that something akin to the sapir-whorf hypothesis applied to programmers--- especially those who have never been taught to abstract the development of algorithms from the development of programs. indeed, i began to worry about the consequences of loosing on the computer centers (and computer science departments) of a horde of programmers whose total background is a rudimentary basic learned in elementary or high school from a teacher who has virtually no actual programming experience.  richard l. wexelblat
object-oriented mechanismsthree groups of requirements were considered in this session:  * object-oriented programming Â- or more specifically, the mechanisms of inheritance and polymorphism.  * general references  * final isationexperience of object-oriented programming amongst the majority of delegateswas fairly limited, so rather than attempt to assess the value of object-oriented mechanisms in themselves attention was focussed on their potentialimpact on the real-time requirements. the session began with a briefintroduction of the requirements, and of the possible strategies forsatisfying them in ada 9x, followed by a general discussion.colin atkinson
optimization of array subscript range checks  compile-time elimination of subscript range checks is performed by some optimizing compilers to reduce the overhead associated with manipulating array data structures. elimination and propagation, the two methods of subscript range check optimization, are less effective for eliminating global redundancies especially in while-loop structures with nonconstant loop guards. this paper describes a subscript range check optimization procedure that can eliminate more range checks than current methods. two transformations called inner-loop guard elimination and conservative expression substitution are introduced to enhance propagation of range checks in nested while-loops and to define a partial order on related range checks. global elimination is improved by considering range checks performed before control reaches a statement and after control leaves a statement. a unique feature of this method is the simplification of the available range-check analysis system for global elimination.  jonathan m. asuru
software caching and computation migration in olden  the goal of the olden project is to build a system that provides parallelism for general purpose c programs with minimal programmer annotations. we focus on programs using dynamic structures such as trees, lists, and dags. we demonstrate that providing both software caching and computation migration can improve the performance of these programs, and provide a compile-time heuristic that selects between them for each pointer dereference. we have implemented a prototype system on the thinking machines cm-5. we describe our implementation and report on experiments with ten benchmarks.  martin c. carlisle anne rogers
bigmac ii: a fortran language augmentation tool  this paper describes the motivation, design, implementation, and some preliminary performance characteristics of bigmac ii, a macro definition capability for creating language enhancers and translators. bigmac ii enables the user to specify transformations through strex, a fortran-like language, which enables the specification of macros which are then used to interpretively alter incoming programs. bigmac ii is specially adapted to the processing of fortran programs. this paper shows how it can be used as a deprocedurizer (or flattener), a dialect-to-dialect translator, a portability and version control aid, and a device for creating language enhancements as sophisticated as new control structures and abstract data types.  eugene w. myers leon j. osterweil
native code process-originated migration in a heterogeneous environment  dynamic migration has been investigated in several research efforts as a vehicle for load sharing, resource sharing, communication overhead reduction, failure robustness, and several other contexts. this paper presents a summary of related work in dynamic migration, and suggests motivations for considering heterogeneous migration. next a design for heterogeneous migration, along with its restrictions is presented. a prototype implementation is described. conclusions are drawn and future work is suggested.  charles m. shub
the architecture of a uml virtual machine current software development tools let developers model a software system and generate program code from the models to run the system. however, generating code and installing a non- trivial system induces a time delay between changing the model and executing it that makes rapid model prototyping awkard if not impossible. this paper presents the architecture of a virtual machine for uml that interprets uml models without any intermediate code-generation step. the paper shows how to embed uml in a metalevel architecture so that a key property of model-based systems, the casual connection between models and model instances, is guaranteed. with this architecture, changes to a model have immediate effects on its execution, providing users with rapid feedback about the model's structure and behavior. this approach supports model innovation better than today's code-generation approaches. dirk riehle steven fraleigh dirk bucka- lassen nosa omorogbe
hopt: a myopic version of the stochopt automatic file migration policy  the stochopt automatic file migration policy (proposed by a.j. smith) minimizes the expected retention and recall costs of an abitrarily sized file. we consider the application of the stochopt policy to a file system in which the file inter-reference time (irt) distributions are characterized by strictly monotonically decreasing hazard rates (sdhr) (also known as decreasing failure rates, dfr). we show that in this case the stochopt policy can be simply stated in terms of a scaled hazard rate, i.e., the hazard rate divided by the file size. such decreasing failure rate distributions have been used by smith to model empirically observed file inter-reference times.  frank olken
temporal sequence learning and data reduction for anomaly detection  the anomaly-detection problem can be formulated as one of learning to characterize the behaviors of an individual, system, or network in terms of temporal sequences of discrete data. we present an approach on the basis of instance-based learning (ibl) techniques. to cast the anomaly-detection task in an ibl framework, we employ an approach that transforms temporal sequences of discrete, unordered observations into a metric space via a similarity measure that encodes intra-attribute dependencies. classification boundaries are selected from an a posteriori characterization of valid user behaviors, coupled with a domain heuristic. an empirical evaluation of the approach on user command data demonstrates that we can accurately differentiate the profiled user from alternative users when the available features encode sufficient information. furthermore, we demonstrate that the system detects anomalous conditions quickly \\--- an important quality for reducing potential damage by a malicious user. we present several techniques for reducing data storage requirements of the user profile, including instance- selection methods and clustering. as empirical evaluation shows that a new greedy clustering algorithm reduces the size of the user model by 70%, with only a small loss in accuracy.  terran lane carla e. brodley
a distributed debugger for amoeba  we describe a debugger that is being developed for distributed programs in amoeba. a major goal in our work is to make the debugger independent of the amoeba kernel. our design integrates many facilities found in other debuggers, such as execution replay, breakpointing, and an event-based view of the execution of the target program. this paper discusses the influence of amoeba's architecture on the attainability of our goals and the desired functionality of the debugger. we also consider such problems as how to deal with timeouts and interactions between the target program and its environment.  i. j. p. elshoff
preliminary experience from the dice system a distributed incremantal compiling environment  abstracts the dice system is a highly integrated programming environment which provides programmer support in the case where the programming environment resides in a host computer and the program is running on a target computer that is connected to the host. such a system configuration is also suitable for remote debugging and maintenance of production versions of programs that has been installed in a user environment.  the system contains tools such as an screen- oriented structure editor, a statement-level incremental compiler, a screen- oriented debugger and a program database. the debugger uses the same facility for pointing and display as does the editor, and it uses the incremental compiler for insertion of breakpoints and statement evaluation. most of these tools are automatically generated from compact descriptions.  this paper describes some aspects of a prototype version of the system and gives some preliminary data on the performance. also, strategies for implementing portable programming environments are discussed and are exemplified by the dice system.  peter fritzson
the effects of solid state paging devices in a large time-sharing system  this paper reports the results of some measurements taken on the effects two new solid state paging devices, the stc 4305 and the intel 3805, have on paging performance in the michigan terminal system at the university of michigan. the measurements were taken with a software monitor using various configurations of the two solid state devices and the fixed head disk, which they replace. measurements were taken both during regular production and using an artificial load created to exercise the paging subsystem. the results confirmed the expectation that the solid state paging devices provide shorter page-in waiting times than the fixed-head disk, and also pointed up some of the effects which their differing architectures have on the system.  john sanguinetti
design of a machine-independent optimizing system for emulator development  methods are described to translate a certain machine-independent intermediate language (iml) to efficient microprograms for a class of horizontal microprogrammable machines. the iml is compiled directly from a high-level microprogramming language used to implement a virtual instruction set processor as a microprogram.  the primary objective of the iml-to-host machine interface design is to facilitate language portability. transportability is accomplished by use of a field description model and a macro expansion table which describe the host machine to the translator system.  register allocation scheme and control flow analysis are employed to allocate the symbolic variables of the iml to the general-purpose registers of the host machine. a set of 5-tuple microoperations (function, input, output, field, phase) is obtained with the aid of the field description model. then a compaction algorithm is used to detect the parallelism of microoperations and to generate suboptimal code for a horizontal microprogrammable machine. the study concludes with a description of the effects of the above methods upon the quality of microcode produced for a specific commercial computer.  perng-ti ma t. g. lewis
disk arm movement in anticipation of future requests  when a disk drive's access arm is idle, it may not be at the ideal location. in anticipation of future requests, movement to some other location may be advantageous. the effectiveness of anticipatory disk arm movement is explored. various operating conditions are considered, and the reduction in seek distances and request response times is determined for them. suppose that successive requests are independent and uniformly distributed. by bringing the arm to the middle of its range of motion when it is idle, the expected seek distance can be reduced by 25 percent. nonlinearity in time versus distance can whittle that 25 percent reduction down to a 13 percent reduction in seek time. nonuniformity in request location, nonpoisson arrival processes, and high arrival rates can whittle the reduction down to nothing. however, techniques are discussed that maximize those savings that are still possible under those circumstances. various systems with multiple arms are analyzed. usually, it is best to spread out the arms over the disk area. the both arms should be brought to the middle.  richard p. king
concurrent objects in ada 95 although implicit parallelism is one of the most important advantages besides methodological and software engineering aspects of the object-oriented paradigm, only a few papers are directly dedicated object-oriented concurrency. based on [boyd87], [clark87], [collard89], and [baker91], each of which appeared in the acm ada letters, this paper addresses the implementation of concurrent object classes using ada 95. it offers a uniform template of the structure of concurrent object subclasses leading to polymorphic methods. finally, a brief remark is made on the importance of generic object classes. hans loeper amro khattab peter neubert
a paradigm for distributed debugging  three critical problems associated with distributed debugging are controlling the debugging process in the absence of a global clock; maintaining transparency so that the debugger does not change the order or timing of events, and reproducing an execution sequence to be able to verify that a fault has been corrected. a paradigm is put forward that successfully addresses these three problems. to demonstrate the feasibility of this paradigm, an instantiation has been constructed. a description is given of the resulting debugger for a dataflow language.  nancy j. wahl stephen r. schach
compiling optimized array operations at run-time  experiments were performed for apl functions on a vax-750 running unix to compare the execution times of two types of interpreted code run time run time compiled code for the dyadic function subtract. the data type and size varied over integer, real, one element, and a 5x5x5x5x5 (=3125) element arrays. the experiment showed a range of more than 2.5:1 in execution times of interpretive code to compiled code.  thomas w. christopher ralph w. wallace
constraining control  continuations, when available as first-class objects, provide a general control abstraction in programming languages. they liberate the programmer from specific control structures, increasing programming language extensibility. such continuations may be extended by embedding them in functional objects. this technique is first used to restore a fluid environment when a continuation object is invoked. we then consider techniques for constraining the power of continuations in the interest of security and efficiency. domain mechanisms, which create dynamic barriers for enclosing control, are implemented using fluids. domains are then used to implement an unwind-protect facility in the presence of first-class continuations. finally, we demonstrate two mechanisms, wind-unwind and dynamic-wind, that generalize unwind-protect.  daniel p. friedman christopher t. haynes
effective software architecture design: from global analysis to uml descriptions  _it is now generally accepted that separating software architecture into multiple views can help in reducing complexity and in making sound decisions about design trade-offs. our four views are based on current practice; they are loosely coupled, and address different engineering concerns [1]. this tutorial will teach you how global analysis can improve your design, and how to use uml to describe these views. you will learn: (1) the purpose of having separate software architecture views, (2) the difference between using uml for software architecture and the use of uml for designing oo implementations, (3) how to apply global analysis to analyze factors that influence the architecture and to develop strategies that guide the design, (4) the importance of designing for anticipated change to produce more maintainable architectures, and (5) how to incorporate software architecture design in your software process._  _this tutorial is aimed at experienced software engineers, architects, and technical managers. it is assumed that participants know the basic uml diagrams. experience in developing models and software design is helpful._  robert l. nord daniel j. paulish dilip soni christine hofmeister
a practical method for lr and ll syntactic error diagnosis and recovery  this paper presents a powerful, practical, and essentially language- independent syntactic error diagnosis and recovery method that is applicable within the frameworks of lr and ll parsing. the method generally issues accurate diagnoses even where multiple errors occur within close proximity, yet seldom issues spurious error messages. it employs a new technique, parse action deferral, that allows the most appropriate recovery in cases where this would ordinarily be precluded by late detection of the error. the method is practical in that it does not impose substantial space or time overhead on the parsing of correct programs, and in that its time efficiency in processing an error allows for its incorporation in a production compiler. the method is language independent, but it does allow for tuning with respect to particular languages and implementations through the setting of language-specific parameters.  michael g. burke gerald a. fisher
towards fully abstract semantics for local variables  the store model of halpern-meyer-trakhtenbrot is shown---after suitable repair ---to be a fully abstract model for a limited fragment of algol in which procedures do not take procedure parameters. a simple counter-example involving a parameter of program type shows that the model is not fully abstract in general. previous proof systems for reasoning about procedures are typically sound for the hmt store model, so it follows that theorems about the counter-example are independent of such proof systems. based on a generalization of standard cpo based models to structures called locally complete partial orders (lcpo's), improved models and stronger proof rules are developed to handle such examples.  a. r. meyer k. sieber