waashk/acm huggingface dataset:
apl two by two-syntax analysis by pairwise reduction  benkard explains the precedence rules of apl with a syntactic binding hierarchy [1,2]. this paper uses the hierarchy as a basis for developing a more formal description of apl syntax which can be applied directly in a syntax analyzer. the flexibility of this approach makes it useful as a basis for examining the effect of proposed syntax changes and the consequences of previous design choices.  j. d. bunda j. a. gerth
understanding the sources of variation in software inspections  in a previous experiment, we determined how various changes in three structural elements of the software inspection process (team size and the number and sequencing of sessions) altered effectiveness and interval. our results showed that such changes did not significantly influence the defect detection rate, but that certain combinations of changes dramatically increased the inspection interval. we also observed a large amount of unexplained variance in the data, indicating that other factors must be affecting inspection performance. the nature and extent of these other factors now have to be determined to ensure that they had not biased our earlier results. also, identifying these other factors might suggest additional ways to improve the efficiency of inspections. acting on the hypothesis that the "inputs" into the inspection process (reviewers, authors, and code units) were significant sources of variation, we modeled their effects on inspection performance. we found that they were responsible for much more variation in detect detection than was process structure. this leads us to conclude that better defect detection techniques, not better process structures, are the key to improving inspection effectiveness. the combined effects of process inputs and process structure on the inspection interval accounted for only a small percentage of the variance in inspection interval. therefore, there must be other factors which need to be identified.  adam porter harvey siy audris mockus lawrence votta
future of ieee standard for ada pdl to be considered the ansi/ieee standard describing ada as a program design language was approved by the ieee in 1986 and reaffirmed in 1992. normal ieee procedures would require that it next be reconsidered for withdrawal, revision or reaffirmation in 1997. the completion of the ada 95 language revision, though, suggests that reconsideration of the standard should be accelerated. after a quick overview of ieee standardization, this article briefly describes the history of the ada/pdl standard and its contents. it poses some of the issues relevant to reconsideration of the standard. finally, it solicits volunteers to help determine the future of the standard. james w. moore
on the logical foundations of staged computation (invited talk)  dividing a computation into stages and optimizing later phases using information from earlier phases is a familiar technique in algorithm design. in the realm of programming languages, staged computation has found two important realizations: partial evaluation and run-time code generation. a priori, these are fundamentally operational concepts, concerned with how a program executes, but not what it computes.  in this talk we provide a logical foundation for staged computation which is consistent with the operational intuition. we concentrate on run-time code generation which is related to modal logic via an interpretation of constructive proofs as programs. this correspondence yields new insights into issues of language design and leads to a static type system in which staging errors become type errors. we sketch the language pml (for phased ml), whose design has been directly motivated by our foundational reconstruction, and discuss our ongoing compiler construction effort [1; 2; 3; 4].  frank pfenning
physical type checking for c the effectiveness of traditional type checking in c is limited by the presence of type conversions using type casts. because the c standard allows arbitrary type conversions between pointer types, neither c compilers, nor tools such as _lint,_ can guarantee type safety in the presence of such type conversions. in particular, by using casts involving pointers to structures (c structs), a programmer can interpret any memory region to be of any desired type, further compromising c's weak type system. not only do type casts make a program vulnerable to type errors, they hinder program comprehension and maintenance by creating latent dependencies between seemingly independent pieces of code.to address these problems, we have developed a stronger form of type checking for c programs, called _physical type checking._ physical type checking takes into account the layout of c struct fields in memory. this paper describes an inference-based physical type checking algorithm. our algorithm can be used to perform static safety checks, as well as compute useful information for software engineering applications. satish chandra thomas reps
integrating object-oriented programming and protected objects in ada 95  integrating concurrent and object-oriented programming has been an active research topic since the late 1980's. there is a now a plethora of methods for achieving this integration. the majority of approaches have taken a sequential object-oriented language and made it concurrent. a few approaches have taken a concurrent language and made it object-oriented. the most important of this latter class is the ada 95 language, which is an extension to the object-based concurrent programming language ada 83. arguably, ada 95 does not fully integrate its models of concurrency and object-oriented programming. for example, neither tasks nor protected objects are extensible. this article discusses ways in which protected objects can be made more extensible.  a. j. wellings b. johnson b. sanden j. kienzle t. wolf s. michell
a programming language based on the concepts of objects and fields  the object-oriented model is very successful to represent various phenomena in our real world from an entity-category point of view. however, it is not sufficient to model the dynamic actions of autonomous entities under this paradigm. this model is in short of representing the relationships between entities and the environments. in this paper, we propose an experimental object-oriented programming language to manage the relationships together.  fumihiko nishio toyohide watanabe noboru sugie
an introduction to partial evaluation  partial evaluation provides a unifying paradigm for a broad spectrum of work in program optimization compiling interpretation and the generation of automatic program generators [bjørner et al. 1987; ershov 1992; and jones et al. 1993]. it is a program optimization technique, perhaps better called program specialization, closely related to but different from jørring and scherlis' staging transformations [1986]. it emphasizes, in comparison with burstall and darlington [1977] and jørring and scherlis [1986] and other program transformation work, full automation and the generation of program generators as well as transforming single programs. much partial evaluation work to date has concerned automatic compiler generation from an interpretive definition of programming language, but it also has important applications to scientific computing, logic programming, metaprogramming, and expert systems; some pointers are given later.  neil d. jones
fine grained data management to achieve evolution resilience in a software development environment  a software development environment (sde) exhibits evolution resilience if changes to the sde do not adversely affect its functionality nor performance, and also do not introduce delays in returning the sde to an operational state after a change. evolution resilience is especially difficult to achieve when manipulating fine grained data, which must be tightly bound to the language in which the sde is implemented to achieve adequate performance. we examine a spectrum of approaches to tool integration that range from high sde- development-time efficiency to high sde- execution-time efficiency. we then present a meta-environment, a specific sde tailored to the development of target sde's, that supports easy movement of individual tools along this spectrum.  richard snodgrass karen shannon
walks into the apl design space  like any living language, apl is evolving. the design space for its future development is wide open. some trails into that space are known, for other languages have followed them. we will walk on some trails, visit some sights and also some dead ends. we will see which development areas could solve some old problems of apl, without changing its fabric.  the goal of the paper is to enable the reader to explore the apl design space on his or her own. to that end i will point the reader to some good books and articles about problems and solutions only touched upon in the paper.  martin gfeller
the impact of interprocedural analysis and optimization in the rn programming environment  in spite of substantial progress in the theory of interprocedural data flow analysis, few practical compiling systems can afford to apply it to produce more efficient object programs. to perform interprocedural analysis, a compiler needs not only the source code of the module being compiled, but also information about the side effects of every procedure in the program containing that module, even separately compiled procedures. in a conventional batch compiler system, the increase in compilation time required to gather this information would make the whole process impractical. in an integrated programming environment, however, other tools can cooperate with the compiler to compute the necessary interprocedural information incrementally. as the program is being developed, decreasing both the overall cost of the analysis and the cost of individual compilations.  a central goal of the rn project at rice university is to construct a prototype software development environment that is designed to build whole programs, rather than just individual modules. it employs interprocedural analysis and optimization to produce high-quality machine code for whole programs. this paper presents an overview of the methods used by the environment to accomplish this task and discusses the impact of these methods on the various environment components. the responsibilities of each component of the environment for the preparation and use of interprocedural information are presented in detail.  keith d. cooper ken kennedy linda torczon
and/or programs: a new approach to structured programming  a simple tree-like programming/specification language is presented. the central idea is the dividing of conventional programming constructs into the two classes of and and or subgoaling, the subgoal tree itself constituting the program. programs written in the language can, in general, be both nondeterministic and parallel. the syntax and semantics of the language are defined, a method for verifying programs written in it is described, and the practical significance of programming in the language assessed. finally, some directions for further research are indicated.  david harel
system structure and software maintenance performance  an experiment is designed to investigate the relationship between system structure and maintainability. an old, ill-structured system is improved in two sequential stages, yielding three system versions for the study. the primary objectives of the research are to determine how or whether the differences in the systems influence maintenance performance; whether the differences are discernible to programmers; and whether the differences are measurable. experienced programmers perform a portfolio of maintenance tasks on the systems. results indicate that system improvements lead to decreased total maintenance time and decreased frequency of ripple effect errors. this suggests that improving old systems may be worthwhile and may yield benefits over the remaining life of the system. system differences are not discernible to programmers; apparently programmers are unable to separate the complexity of the systems from the complexity of the maintenance tasks. this finding suggests a need for further research on the efficacy of subjectively based software metrics. finally, results indicate that a selected set of automatable, objective complexity metrics reflected both the improvements in the system and programmer maintenance performance. these metrics appear to offer potential as project management tools.  virginia r. gibson james a. senn
identifying procedural structure in cobol programs the principal control-flow abstraction mechanism in the cobol language is the perform statement. normally, perform statements are used in a straightforward manner to define parameterless procedures (where global variables are used to pass data into and out of procedure bodies). however, unlike most procedural constructs, distinct performed procedures can share code in arbitrarily complicated ways. in addition, performs can also be used in such a way as to cause transfers of control that do not correspond to normal call/return semantics.in this paper, we show how a cobol program can be efficiently transformed into a semantically-equivalent _procedurally well-structured_ representation, in which conventional procedures (i.e., with the usual call and return semantics and without code sharing) and procedure call statements replace performed code and perform statements. this transformation process properly accounts for the non-procedural control flow that can result from ill-behaved perform statements.the program representation derived from our analysis can be used directly in program understanding applications, program restructuring tools, and inter-language translators. in addition, it can be used as the starting point for a variety of context-sensitive program analyses, e.g., program slicing. john field g. ramalingam
implementing signatures for c++  we outline the design and detail the implementation of a language extension for abstracting types and for decoupling subtyping and inheritance in c++. this extension gives the user more of the flexibility of dynamic typing while retaining the efficiency and security of static typing. after a brief discussion of syntax and semantics of this language extension and examples of its use, we present and analyze three different implementation techniques: a preprocessor to a c++ compiler, an implementation in the front end of a c++ compiler, and a low-level implementation with back-end support. we follow with an analysis of the performance of the three implementation techniques and show that our extension actually allows subtype polymorphism to be implemented more efficiently than with virtual functions. we conclude with a discussion of the lessons we learned for future programming language design.  gerald baumgartner vincent f. russo
continuation-passing, closure-passing style  we implemented a continuation-passing style (cps) code generator for ml. our cps language is represented as an ml datatype in which all functions are named and most kinds of ill-formed expressions are impossible. we separate the code generation into phases that rewrite this representation into ever-simpler forms. closures are represented explicitly as records, so that closure strategies can be communicated from one phase to another. no stack is used. our benchmark data shows that the new method is an improvement over our previous, abstract- machine based code generator.  a. w. appel t. jim
quicktalk: a smalltalk-80 dialect for defining primitive methods  quicktalk is a dialect of smalltalk-80 that can be compiled directly into native machine code, instead of virtual machine bytecodes. the dialect includes "hints" on the class of method arguments, instance variables, and class variables. we designed the dialect to describe primitive smalltalk methods. quicktalk achieves improved performance over bytecodes by eliminating the interpreter loop on bytecode execution, by reducing the number of message send/returns via binding some target methods at compilation, and by eliminating redundant class checking. we identify changes to the smalltalk-80 system and compiler to support the dialect, and give performance measurements.  mark b. ballard david maier allen wirfs- brock
re2c: a more versatile scanner generator  it is usually claimed that lexical analysis routines are still coded by hand, despite the widespread availability of scanner generators, for efficiency reasons. while efficiency is a consideration, there exist freely available scanner generators such as gla [gray 1988] that can generate scanners that are faster than most hand- coded ones. however, most generated scanners are tailored for a particular environment, and retargeting these scanners to other environments, if possible, is usually complex enough to make a hand-coded scanner more appealing. in this paper we describe re2c, a scanner generator that not only generates scanners that are faster (and usually smaller) than those produced by any other scanner generator known to the authors, including gla, but that also adapt easily to any environment.  peter bumbulis donald d. cowan
empirical investigation of a novel approach to check the integrity of software engineering measuring processes (poster session)  this distribution is counter-intuitive for at least two reasons. first it would seem "obvious" that the numbers drawn from a list generated from widely different arbitrary processes would have roughly equally probabilities for the digits 1 and 9 to be first digits. this is not normally the case. if the list of numbers does not have artificial limits, or include invented numbers such as postal codes, then approximately 30% of the numbers will have 1 as their first digit, but only 5% will have 9 as their first digit. deviations from the expected benford distribution indicate the presence of some special characteristic of the data. the second, more theoretically challenging, problem is: what is the underlying property associated with so many widely different processes which generates lists of numbers that follow benford's law?  we have conducted an empirical investigation to determine under what circumstances various software metrics follow benford's law, and whether any special characteristics, or irregularities, in the data can be uncovered if the data are found not to follow the law. the more tricky problem of understanding why the list of metrics might follow benford's law is left to another study.  lists were form from three software metrics extracted from 100 public domain industrial java projects. these metrics were lines of code (loc), fan-out (fo) and mccabe cyclomatic complexity (mcc). given that a benford's law analysis requires a list of considerable length, the data were divided into two groups. the first groups was from projects containing more than 100 files. this was intended as the "control group" and what was expected to follow benford's law if that law was applicable for the analysis of software engineering metrics. to study the sensitivity of the digital analysis technique to project size, projects with a smaller number of files were compared to the control group.  the empirical results indicate that the first digits of numbers in lists of loc metrics extracted from the projects closely followed the probabilities predicted by benford's law than an "equal probability of occurrence" suggested by intuitive reasoning. this was shown using both qualitative and quantitative measures. the fo and mcc metrics did not follow the standard benford's law as well as did the loc metrics. this is because the fo and mcc lists contain a significant number of numbers less than 10 and follow a different first digit distribution. further investigation of the digital analysis technique is necessary to evaluate the applicability of benford's law in the total context of software metrics.  skylar lei michael smith giancarlo succi
a software technology evaluation program (abstract only)  a wealth of potentially beneficial software engineering tools, practices, and techniques has emerged in the past several years. simultaneously, realization has grown that all software engineering technologies are not equally effective for all software development problems and environments. the software engineering laboratory (sel), a cooperative project of the national aeronautics and space administration, computer sciences corporation, and the university of maryland, conducts an extensive technology evaluation program. measurement is the basic prerequisite for evaluation. the sel collects measures on the production of fortran software for spacecraft navigation systems. recent sel investigations demonstrated that the use of structured programming and quality assurance improves software reliability. however, the major factor in both productivity and reliability continues to be personnel capability. such technology evaluation programs provide an empirical basis for defining software development standards and selecting tools.  david n. card
a report on random testing  random testing of programs is usually (but not always) viewed as a worst case of program testing. test case generation that takes into account the program structure is usually preferred. path testing is an often proposed ideal for structural testing. path testing is treated here as an instance of partition testing. (partition testing is any testing scheme which forces execution of at least one test case from each subset of a partition of the input domain.) simulation results are presented which treat path and partition testing in a reasonably favorable way, and yet still suggest that random testing may often be more cost effective. results of actual random testing experiments are presented which tend to confirm the viability of random testing as a useful validation tool.  joe w. duran simeon ntafos
a framework for remote dynamic program optimization  dynamic program optimization allows programs to be generated that are highly tuned for a given environment and input data set. optimization techniques can be applied and re- applied as program and machine characteristics are discovered and change. in most dynamic optimization and compilation frameworks, the time spent in code generation and optimization must be minimized since it is directly reflected in the total program execution time. we propose a generic framework for remote dynamic program optimization that mitigates this need. a local optimizer thread monitors the program as it executes and selects program sections that should be optimized. an optimizer, running on a remote machine or a free processor of a multiprocessor, is then called to actually perform the optimization and generate a new code variant for the section. a dynamic selector is used to select the most appropriate code variant for each code interval based upon the current runtime environment. we describe this framework in detail and present an example of its use on a simple application. we show that our framework, when used with changing input, can outperform the best statically optimized version of the application.  michael j. voss rudolf eigenmann
developing an object-oriented software testing and maintenance environment  the object-oriented (oo) paradigm is rapidly gaining acceptance in the software industry. however, the powerful features of this new paradigm also introduce a new set of oo software testing and maintenance problems. the pioneering work in identifying these new problems includes [7, 10-12, 14, 16, 18]. the problems can be summarized as: 1) the understanding problem; 2) the complex interdependency problem; 3) the object state behavior testing problem; and 4) the tool support problem. detailed discussions of these problems will be provided later. our industrial experience confirms these discoveries.  david kung jerry gao pei hsia yasufumi toyoshima chris chen young-si kim young-kee song