waashk/acm huggingface dataset:
exception handling and object-oriented programming: towards a synthesis  the paper presents a discussion and a specification of an exception handling system dedicated to object-oriented programming. we show how a full object- oriented representation of exceptions and of protocols to handle them, using meta-classes, makes the system powerful as well as extendible and solves many classical exception handling issues. we explain the interest for object- oriented programming of handlers attached to classes and to expressions. we propose an original algorithm for propagating exceptions along the invocation chain which takes into account, at each stack level, both kind of handlers. any class can control which exceptions will be propagated out of its methods; any method can provide context-dependant answers to exceptional events. the whole specification and some keys of our smalltalk implementation are presented in the paper.  christophe dony
experimental results from an automatic test case generator  constraint-based testing is a novel way of generating test data to detect specific types of common programming faults. the conditions under which faults will be detected are encoded as mathematical systems of constraints in terms of program symbols. a set of tools, collectively called godzilla, has been implemented that automatically generates constraint systems and solves them to create test cases for use by the mothra testing system. experimental results from using godzilla show that the technique can produce test data that is very close in terms of mutation adequacy to test data that is produced manually, and at substantially reduced cost. additionally, these experiments have suggested a new procedure for unit testing, where test cases are viewed as throw-away items rather than scarce resources.  richard a. demillo a. jefferson offutt
an automatically generated, realistic compiler for imperative programming language  we describe the automatic generation of a complete, realistic compiler from formal specifications of the syntax and semantics of sol/c, a nontrivial imperative language "sort of like c." the compiler exhibits a three pass structure, is efficient, and produces object programs whose performance characteristics compare favorably with those produced by commercially available compilers. to our knowledge, this is the first time that this has been accomplished.  u. f. pleban p. lee
multi-dimensional modelling and measurement of software designs  design structure measures are example of a class of metrics that may be derived early on in a software project; they are useful indicators of design weaknesses - weaknesses which, if uncorrected, lead to problems of implementation, reliability and maintainability. unfortunately, structure metrics are limited in their ability to model system architecture since they are insensitive to component size. thus, architectures that trade structural complexity for very large components may not be detected. this paper has two concerns. first, we consider the problem of adequately measuring component size at design time. various existing metrics are evaluated and found to be deficient. consequently, a new, more flexible approach based upon the traceability from system requirements to design components, is proposed. second, we address the issue of multi-dimensional modelling (in this case structure and size). we apply outlier analysis techniques to identify three classes of problem design component and relate our work to an empirical study of 62 modules. the results suggest that augmenting the more traditional approach of a single structure metric with an additional perspective, that of module size, considerably enhances the ability of design metrics to isolate problem components. it is our belief that far more sophisticated software modelling techniques, such as the multi-dimensional approach we present, are required, if measurement and modelling is to reach its full potential, as an integral part of software engineering processes.  martin shepperd darrel ince
c and tcc: a language and compiler for dynamic code generation  dynamic code generation allows programmers to use run-time information in order to achieve performance and expressiveness superior to those of static code. the 'c(tick c) language is a superset of ansi c that supports efficient and high-level use of dynamic code generation. 'c provides dynamic code generation at the level of c expressions and statements and supports the composition of dynamic code at run time. these features enable programmers to add dynamic code generation to existing c code incrementally and to write important applications (such as "just-in-time" compilers) easily. the article presents many examples of how 'c can be used to solve practical problems. the tcc compiler is an efficient, portable, and freely available implementation of 'c. tcc allows programmers to trade dynamic compilation speed for dynamic code quality: in some aplications, it is most important to generate code quickly, while in others code quality matters more than compilation speed. the overhead of dynamic compilation is on the order of 100 to 600 cycles per generated instruction, depending on the level of dynamic optimizaton. measurements show that the use of dynamic code generation can improve performance by almost an order of magnitude; two- to four-fold speedups are common. in most cases, the overhead of dynamic compilation is recovered in under 100 uses of the dynamic code; sometimes it can be recovered within one use.  massimiliano poletto wilson c. hsieh dawson r. engler m. frans kaashoek
bridging the requirements/design gap in dynamic systems with use case maps (ucms)  two important aspects of future software engineering techniques will be the ability to seamlessly move from analysis models to design models and the ability to model dynamic systems where scenarios and structures may change at run-time. use case maps (ucms) are used as a visual notation for describing causal relationships between responsibilities of one or more use cases. ucms are a scenario-based software engineering technique most useful at the early stages of software development. the notation is applicable to use case capturing and elicitation, use case validation, as well as high-level architectural design and test case generation. ucms provide a behavioural framework for evaluating and making architectural decisions at a high level of design. architectural decisions may be based on performance analysis of ucms. ucms bridge the gap between requirements and design by combining behaviour and structure in one view and by flexibly allocating scenario responsibilities to architectural components. they also provide dynamic (run-time) refinement capability for variations of scenarios and structure and they allow incremental development and integration of complex scenarios. therefore, ucms address the issues mentioned above.  daniel amyot gunter mussbacher
the omg, corba, orbix and ada an object request broker (orb) mediates between applications - including distributed ones. this document presents the design goals and philosophy that lead iona technologies to produce the object request broker, orbix. the ada language binding is described, and some simple programming examples are given to illustrate its operation.the introduction discusses the needs for orbs and the industry initiatives that arose from that need - culminating in the omg's corba specifications. david clarke
incremental global reoptimization of programs  although optimizing compilers have been quite successful in producing excellent code, two factors that limit their usefulness are the accompanying long compilation times and the lack of good symbolic debuggers for optimized code. one approach to attaining faster recompilations is to reduce the redundant analysis that is performed for optimization in response to edits, and in particulars, small maintenance changes, without affecting the quality of the generated code. although modular programming with separate compilation aids in eliminating unnecessary recompilation and reoptimization, recent studies have discovered that more efficient code can be generated by collapsing a modular program through procedure inlining. to avoid having to reoptimize the resultant large procedures, this paper presents techniques for incrementally incorporating changes into globally optimized code. an algorithm is given for determining which optimizations are no longer safe after a program change, and for discovering which new optimizations can be performed in order to maintain a high level of optimization. an intermediate representation is incrementally updated to reflect the current optimizations in the program. analysis is performed in response to changes rather than in preparation for possible changes, so analysis is not wasted if an edit has no far-reaching effects. the techniques developed in this paper have also been exploited to improve on the current techniques for symbolic debugging of optimized code.  lori l. pollock mary lou soffa
a mark-and-sweep collector c++  our research is concerned with compiler-independent, tag-free garbage collection for the c++ programming language. we have previously presented a copying collector based on root registration. this paper presents a mark-and- sweep garbage collector that ameliorates shortcomings of the previous collector. we describe the two collectors and discuss why the new one is an improvement over the old one. we have tested this collector and a conservative collector in a vlsi cad application, and this paper discusses the differences. currently this prototype of the collector imposes too much overhead on our application. we intend to solve that problem, and then use the techniques described in this paper to implement a generational mark-and-sweep collector for c++.  daniel r. edelson
a measure of program locality and its application  although the phenomenon of locality has long been recognized as the single most important characteristic of program behaviour, relatively little work has been done in attempting to measure it. recent work has led to the development of an intrinsic measure of program locality based on the bradford-zipf distribution. potential applications for such a measure are many, and include the evaluation of program restructuring methods (manual and automatic), the prediction of system performance, the validation of program behaviour models, and the enhanced understanding of the phenomena that characterize program behaviour. a consideration of each of these areas is given in connection with the proposed measure, both to increase confidence in the validity of the measure and to illustrate a methodology for dealing with such problems.  richard b. bunt jennifer m. murphy shikharesh majumdar
control of structure and evaluation  scalar conformance controls the structure phase of expression evaluation. program control of this phase is achieved through insertion and deletion of scalar levels of structure. the basic functions to do this are enclose and disclose with axis. their application in some common cases is made easier with proposed extensions to bracket index and interval. this approach provides the function of a rank operator with greater flexibility while keeping data structure information with the data.  a number of simple expression transformations have proved useful experimentally. two operators are defined which in their several invocations provide full and partial currying and commutation of left and right arguments; composition, power, and dual of functions; composition, conversion between dyadic and monadic function syntax.  the variations in the definitions of partitions have led to suggestions that more than one primitive operation may be needed. extensions to each and enclose are proposed which provide a wide range of function while satisfying numerous identities. since these two operations are each used in apl2 to create a level of structure, the extensions are appropriate.  j. philip benkard
active network vision and reality: lessions from a capsule-based system although active networks have generated much debate in the research community, on the whole there has been little hard evidence to inform this debate. this paper aims to redress the situation by reporting what we have learned by designing, implementing and using the ants active network toolkit over the past two years. at this early stage, active networks remain an open research area. however, we believe that we have made substantial progress towards providing a more flexible network layer while at the same time addressing the performance and security concerns raised by the presence of mobile code in the network. in this paper, we argue our progress towards the original vision and the difficulties that we have not yet resolved in three areas that characterize a "pure" active network: the capsule model of programmability; the accessibility of that model to all users; and the applications that can be constructed in practice. david wetherall
architectural considerations for next generation file systems  we evaluate two architectural alternatives---partitioned and integrated---for designing next generation file systems. whereas a partitioned server employs a separate file system for each application class, an integrated file server multiplexes its resources among all application classes; we evaluate the performance of the two architectures with respect to sharing of disk bandwidth among the application classes. we show that although the problem of sharing disk bandwidth in integrated file systems is conceptually similar to that of sharing network link bandwidth in integrated services networks, the arguments that demonstrate the superiority of integrated services networks over separate networks are not applicable to file systems. furthermore, we show that: (i) an integrated server outperforms the partitioned server in a large operating region and has slightly worse performance in the remaining region, (ii) the capacity of an integrated server is larger than that of the partitioned server, and (iii) an integrated server outperforms the partitioned server by up to a factor of 6 in the presence of bursty workloads.  prashant shenoy pawan goyal harrick m. vin
the chaining approach for software test data generation  software testing is very labor intensive and expensive and accounts for a significant portion of software system development cost. if the testing process could be automated, the cost of developing software could be significantly reduced. test data generation in program testing is the process of identifying a set of test data that satisfies a selected testing criterion, such as statement coverage and branch coverage. in this article we present a chaining approach for automated software test data generation which builds on the current theory of execution-oriented test data generation. in the chaining approach, test data are derived based on the actual execution of the program under test. for many programs, the execution of the selected statement may require prior execution of some other statements. the existing methods of test data generation may not efficiently generate test data for these types of programs because they only use control flow information of a program during the search process. the chaining approach uses data dependence analysis to guide the search process, i.e., data dependence analysis automatically identifies statements that affect the execution of the selected statement. the chaining approach uses these statements to form a sequence of statements that is to be executed prior to the execution of the selected statement. the experiments have shown that the chaining approach may significantly improve the chances of finding test data as compared to the existing methods of automated test data generation.  roger ferguson bogdan korel
corba and corba services for dsa comparing corba and the ada 95 distributed systems annex shows that an advantage of corba is its common object services, providing standard, frequently-used components for distributed application development. this paper presents our implementation of similar services for the dsa. we also introduce new developments of our team that aim at providing close interaction between corba and ada applications. part of the work presented here was accomplished by the adabroker team: fabien azavant, emmanuel chavane, jean-marie cottin, tristan gingold, laurent k bler, vincent niebel, and sebastien ponce. laurent pautet thomas quinot samuel tardieu
efficient java rmi for parallel programming java offers interesting opportunities for parallel computing. in particular, java remote method invocation (rmi) provides a flexible kind of remote procedure call (rpc) that supports polymorphism. sun's rmi implementation achieves this kind of flexibility at the cost of a major runtime overhead. the goal of this article is to show that rmi can be implemented efficiently, while still supporting polymorphism and allowing interoperability with java virtual machines (jvms). we study a new approach for implementing rmi, using a compiler-based java system called manta. manta uses a native (static) compiler instead of a just- in-time compiler. to implement rmi efficiently, manta exploits compile-time type information for generating specialized serializers. also, it uses an efficient rmi protocol and fast low-level communication protocols.a difficult problem with this approach is how to support polymorphism and interoperability. one of the consequences of polymorphism is that an rmi implementation must be able to download remote classes into an application during runtime. manta solves this problem by using a dynamic bytecode compiler, which is capable of compiling and linking bytecode into a running application. to allow interoperability with jvms, manta also implements the sun rmi protocol (i.e., the standard rmi protocol), in addition to its own protocol.we evaluate the performance of manta using benchmarks and applications that run on a 32-node myrinet cluster. the time for a null-rmi (without parameters or a return value) of manta is 35 times lower than for the sun jdk 1.2, and only slightly higher than for a c-based rpc protocol. this high performance is accomplished by pushing almost all of the runtime overhead of rmi to compile time. we study the performance differences between the manta and the sun rmi protocols in detail. the poor performance of the sun rmi protocol is in part due to an inefficient implementation of the protocol. to allow a fair comparison, we compiled the applications and the sun rmi protocol with the native manta compiler. the results show that manta's null-rmi latency is still eight times lower than for the compiled sun rmi protocol and that manta's efficient rmi protocol results in 1.8 to 3.4 times higher speedups for four out of six applications. jason maassen rob van nieuwpoort ronald veldema henri bal thilo kielmann ceriel jacobs rutger hofman
interprocedural constant propagation  in a compiling system that attempts to improve code for a whole program by optimizing across procedures, the compiler can generate better code for a specific procedure if it knows which variables will have constant values, and what those values will be, when the procedure is invoked. this paper presents a general algorithm for determining for each procedure in a given program the set of inputs that will have known constant values at run time. the precision of the answers provided by this method are dependent on the precision of the local analysis of individual procedures in the program. since the algorithm is intended for use in a sophisticated software development environment in which local analysis would be provided by the source editor, the quality of the answers will depend on the amount of work the editor performs. several reasonable strategies for local analysis with different levels of complexity and precision are suggested and the results of a prototype implementation in a vectorizing fortran compiler are presented.  david callahan keith d. cooper ken kennedy linda torczon
reuse that pays  a company builds a software system capable of running a diesel engine in a week, and in one case over a weekend, as opposed to the full year that it used to take. another company builds one of its typical systems with 13 software engineers instead of the more than 100 it once required, and at the same time decreases the systems defect rate ten-fold. still another increases its software-intensive product offerings from four per year to 50 per year. imagine being able to use one person to integrate and test 1.5 million source lines of ada for a real-time command-and-control system onboard a ship, with safety-critical requirements? or increasing software productivity four-fold over three years, as another company has done? these organizations all achieved their results through strategic software reuse. we software people have been promising the benefits of reuse for decades. are we finally achieving a reuse strategy that lives up to its hype?  linda m. northrop
using symbolic execution for verification of ada tasking programs  a method is presented for using symbolic execution to generate the verification conditions required for proving correctness of programs written in a tasking subset of ada. the symbolic execution rules are derived from proof systems that allow tasks to be verified independently in local proofs, which are then checked for cooperation. the isolation nature of this approach to symbolic execution of concurrent programs makes it better suited to formal verification than the more traditional interleaving approach, which suffers from combinatorial problems. the criteria for correct operation of a concurrent program include partial correctness, as well as more general safety properties, such as mutual exclusion and freedom from deadlock.  laura k. dillon
adaptive search techniques applied to software testing  an experiment was performed in which executable assertions were used in conjuction with search techniques in order to test a computer program automatically. the program chosen for the experiment computes a position on an orbit from the description of the orbit and the desired point.  errors were interested in the program randomly using an error generation method based on published data defining common error types. assertions were written for program and it was tested using two different techniques. the first divided up the range of the input variables and selected test cases from within the sub- ranges. in this way a "grid" of test values was constructed over the program's input space.  the second used a search algorithm from optimization theory. this entailed using the assertions to define an error function and then maximizing its value. the program was then tested by varying all of them. the results indicate that this search testing technique was as effective as the grid testing technique in locating errors and was more efficient. in addition, the search testing technique located critical input values which helped in writing correct assertions.  j. p. benson
impact of economics on compiler optimization  compile-time program optimizations are similar to poetry: more are written than are actually published in commercial compilers. hard economic reality is that many interesting optimizations have too narrow an audience to justify their cost in a general-purpose compiler, and custom compilers are too expensive to write. an alternative is to allow programmers to define their own compile-time optimizations. this has already happened accidentally for c++, albeit imperfectly, in the form of template metaprogramming. this paper surveys the problems, the accidental success, and what directions future research might take to circumvent current economic limitations of monolithic compilers.  arch d. robison