waashk/acm huggingface dataset:
beyond traditional program slicing traditional program slices are based on variables and statements. slices consist of statements that potentially affect (or are affected by) the value of a particular variable at a given statement. two assumptions are implicit in this definition: 1) that variables and statements are concepts of the programming language in which the program is written, and 2) that slices consist solely of statements.generalised slicing is an extension of traditional slicing where variables are replaced by arbitrary named program entities and statements by arbitrary program constructs. a model of generalised slicing is presented that allows the essence of any slicing tool to be reduced to a node marking process operating on a program syntax tree. slicing tools can thus be implemented in a straight- forward way using tree-based techniques such as attribute grammars.a variety of useful program decompositions are shown to be instances of generalised slicing including: call graph generation, interface extraction, slicing of object-oriented inheritance hierarchies and slices based on type dependences. examples are also given of how slicing can enhance understanding of formal compiler specifications and aid the creation of subset language specifications. anthony m. sloane jason holdsworth
fsm - a fullscreen manager  fsm is a set of utility functions used in developing fullscreen apl systems at the upjohn company. defining panels and validating input data can be a tedious and time consuming process. fsm simplifies the construction of user dialogues by providing two methods for designing panels, by creating help panels for each screen and input field, and by providing three types of documentation on each panel. it automates checking of user input, scrolling on selected fields, aborting input under program or user signal, and controlling field processing with edit codes, missing values, fill characters, and left/right justification. fsm was originally developed in conjunction with work on a pharmaceutical manufacturing receiving system. the use of nested arrays simplified implementation and contributes to its ease of use. the purpose of the paper will be to describe the capabilities of fsm as influenced by feedback from other development analysts.  r. j. busman
macro processing in high-level languages  a macro language is proposed. it enables macro processing in high-level programming languages. macro definitions in this language refer to the grammars of the respective programming languages. these macros introduce new constructs in programming languages. it is described how to automatically generate macro processors from macro definitions and programming language grammars written in the lex-yacc format. examples of extending high-level languages by means of macros are given.  alexander sakharov
brackets are a pl's best friend bracket notation has been widely criticized, recently at apl86, as inconsistent and anomalous, and operators and functions have been developed in the new apls to wipe outat least some uses of brackets. although adin falkoff has valiantly tried to defend them (and jon mcgrew apologetically), brackets clearly need all the friends they can get.this paper has been written to point out again that brackets have more virtues than vices, that they represent a valuable notational convenience that has not yet been fully exploited, and that they could well be exploited to stand for another component of apl on a par with functions and operators. n. holmes
graph rewrite systems for program optimization  graph rewrite systems can be used to specify and generate program optimizations. for termination of the systems several rule-based criteria are developed, defining exhaustive graph rewrite systems. for nondeterministic systems stratification is introduced which automatically selects single normal forms. to illustrate how far the methodology reaches, parts of the lazy code motion optimization are specified. the resulting graph rewrite system classes can be evaluated by a uniform algorithm, which forms the basis for the optimizer generator optimix. with this tool several optimizer components have been generated, and some numbers on their speed are presented.  uwe assmann
partial method compilation using dynamic profile information the traditional tradeoff when performing dynamic compilation is that of fast compilation time versus fast code performance. most dynamic compilation systems for java perform selective compilation and/or optimization at a method granularity. this is the not the optimal granularity level. however, compiling at a sub- method granularity is thought to be too complicated to be practical. this paper describes a straightforward technique for performing compilation and optimizations at a finer, sub-method granularity. we utilize dynamic profile data to determine intra-method code regions that are rarely or never executed, and compile and optimize the code without those regions. if a branch that was predicted to be rare is actually taken at run time, we fall back to the interpreter or dynamically compile another version of the code. by avoiding compiling and optimizing code that is rarely executed, we are able to decrease compile time significantly, with little to no degradation in performance. futhermore, ignoring rarely-executed code can open up more optimization opportunities on the common paths. we present two optimizations---partial dead code elimination and rare-path-sensitive pointer and escape analysis---that take advantage of rare path information. using these optimizations, our technique is able to improve performance beyond the compile time improvements john whaley
examples of event handling in apl2  event handling is a feature that has recently been added to many apl systems. ibm's vsapl release 4.0 and apl2 include a dyadic system function @@@@ea (execute alternate) which provides a simple event handling facility. this dyadic function can easily be simulated using the event handling facilities offered by other vendors. event handling provides a significant new direction in capability to apl. some applications that are inconvenient or impractical are easily accomplished using event handling. the examples given show some novel uses that may not be obvious on first introduction to @@@@ea. although the examples given here are specific to apl2 the ideas behind them may be used on any apl system with sufficiently powerful event handling.  alan graham
high-integrity code generation for state-based formalisms  we are attempting to create a translator for a formal state-based specification language (rsml-ε) that is suitable for use in safety-critical systems. for such a translator, there are two main concerns: the generated code must be shown to be semantically equivalent to the specification, and it must be fast enough to be used in the intended target environment. we address the first concern by providing a formal proof of the translation, and by keeping the implementation of the tool as simple as possible. the second concern is addressed through a variety of methods: (1) decomposing a specification into parallel subtasks, (2) providing provably- correct optimizations, and (3) making worst-case performance guarantees on the generated code.  michael w. whalen
search and strategies in opl  opl is a modeling language for mathematical programming and combinatorial optimization. it is the first language to combine high-level algebraic and set notations from mathematical modeling languages with a rich constraint language and the ability to specify search procedures and strategies that are the essence of constraint programming. this paper describes the facilities available in opl to specify search procedures. it describes the abstractions of opl to specify both the search tree (search) and how to explore it (strategies). the paper also illustrates how to use these high-level constructs to implement traditional search procedures in constraint programming and scheduling.  pascal van hentenryck laurent perron jean-françois puget
lessons from the design of the eiffel libraries  the nature of programming is changing. most of the software engineering literature still takes for granted a world of individual projects, where the sole aim is to produce specific software systems in response to particular requirements, little attention being paid to each system's relationship to previous or subsequent efforts. this implicit model seems unlikely to allow drastic improvements in software quality and productivity.  such order-of-magnitude advances will require a process of industrialization, not unlike what happened in those disciplines which have been successful at establishing a production process based on the reuse of quality-standardized components. this implies a shift to a "new culture" [14] whose emphasis is not on projects but instead on components.  the need for such a shift was cogently expressed more than 20 years ago by doug mcilroy in his contribution, entitled mass- produced software components [10], to the now-famous first conference on software engineering:  software production today appears in the scale of industrialization somewhere below the more backward construction industries. i think its proper place is considerably higher, and would like to investigate the prospects for mass- production techniques in software. [...]  my thesis is that the software industry is weakly founded [in part because of] the absence of a software components subindustry [...] a components industry could be immensely successful.  although reuse has enjoyed modest successes since this statement was made, by all objective criteria mcilroy's prophecy has not been fulfilled yet; many technical and non-technical issues had to be addressed before reuse could become a reality on the scale he foresaw. (see [1] and [20] for a survey of current work on reuse.) one important development was needed to make this possible: the coming age of object-oriented technology, which provides the best known basis for reusable software construction. (that the founding document of object-oriented methods, the initial description of simula 67, was roughly contemporary with mcilroy's paper tends to confirm a somewhat pessimistic version of redwine and riddle's contention [18] that "it takes on the order of 15 to 20 years to mature a technology to the point that it can be popularized to the technical community at large.") much of the current excitement about object- oriented software construction derives from the growing realization that the shift is now technically possible.  this article presents the concerted efforts which have been made to advance the cause of component-based software development in the eiffel environment [12, 17] through the construction of the basic eiffel libraries.  after a brief overview of the libraries, this article reviews the major language techniques that have made them possible (with more background about eiffel being provided by the sidebar entitled "major eiffel techniques"); it then discusses design issues for libraries of reusable components, the use of inheritance hierarchies, the indexing problem, and planned developments.  bertrand meyer
an explorative journey from architectural tests definition down to code tests execution  _our research deals with the use of the software architecture (sa) as a reference model for the conformance testing of the implemented system with respect to its architectural specification, at the integration test level. having formerly identified an approach to derive architectural test plans, we investigate here the practical meaning of a high level test case defined in terms of architectural processes and messages, such as the ones derived by our approach. indeed, establishing a relation between sa tests (here formulated as paths derived over labeled transition systems expressing the sa dynamics) and concrete, executable tests is not obvious at all. in this paper we describe the steps to be followed to refine architectural tests into code level tests, and we do so in an empirical context by illustrating our hands-on experience in running some of the derived architectural tests on the trmcs case study. we present interesting insights and some preliminary attempts to generalize problems and solutions._  antonia bertolino paola inverardi henry muccini
affix grammar driven code generation  affix grammars are used to describe the instruction set of a target architecture for purposes of compiler code generation. a code generator is obtained automatically for a compiler using attributed parsing techniques. a compiler built on this model can automatically perform most popular machine- dependent optimizations, including peephole optimizations. code generators based on this model demonstrate retargetability for the vax1-11, iapx2-86, z-80003, pdp4-11, mc-68000, ns32032, fom, and ibm-370 architectures.  mahadevan ganapathi charles n. fischer
multilanguage programming on the jvm: the ada 95 benefits the latest trend in our industry, "pervasive computing", predicts the proliferation of numerous, often invisible, computing devices embedded in consumer appliances connected to the ubiquitous internet. secure, reliable applications combined with simplicity of use will make or break a company's reputation in this market.the java "write once, run anywhere" paradigm, introduced by sun in the mid-90s, is embodied in a widely available computing platform targeting pervasive devices. although the java virtual machine was designed to support the semantics of the java programming language, it can also be used as a target for other languages.the ada 95 programming language is a good match for the java platform from the standpoint of its portability, security, reliability, and rich feature set. in this article we explain the features that have made ada the language of choice for software-critical applications and how these features complement the java programming language while increasing the overall reliability and flexibility of the java platform. franco gasperoni gary dismukes
the coupling effect: fact or fiction  fault-based testing strategies test software by focusing on specific, common types of errors. the coupling effect states that test data sets that detect simple types of faults are sensitive enough to detect more complex types of faults. this paper describes empirical investigations into the coupling effect over a specific domain of software faults. all the results from this investigation support the validity of the coupling effect. the major conclusion from this investigation is that by explicitly testing for simple faults, we are also implicitly testing for more complicated faults. this gives us confidence that fault-based testing is an effective means of testing software.  a. offutt
inc: a language for incremental computations  an incremental computation is one that is performed repeatedly on nearly identical inputs. incremental computations occur naturally in many environments, such as compilers, language-based editors, spreadsheets, and formatters. this article describes a proposed tool for making it easy to write incremental programs. the tool consists of a programming language, inc, and a set of compile-time transformations for the primitive elements of inc. a programmer defines an algorithm in inc without regard to efficient incremental execution. the transformations automatically convert this algorithm into an efficient incremental algorithm. inc is a functional language. the implementation of an inc program is a network of processes. each inc function is transformed into a process that receives and transmits messages describing changes to its inputs and outputs. we give an overview to the language and illustrate the incremental techniques employed by inc. we present the static and incremental complexity bounds for the primitive inc functions. we also present some example programs illustrating inc's flexibility. daniel m. yellin robert e. strom
efficient interprocedural analysis for program parallelization and restructuring  an approach to efficient interprocedural analysis for program parallelization and restructuring is presented. such analysis is needed for parallelizing loops which contain procedure calls. our approach captures call effect on data dependencies by propagating the precise information of array subscripts from the called procedure. this allows the optimizing compiler to choose an efficient yet precise data dependence test scheme depending on the complexity of array reference patterns. the other existing methods do not provide such flexibility, hence may suffer from either imprecision or inefficiency. the paper also discusses usage of classical summary information in several important transformations for program parallelization. experimental results are reported.  zhiyuan li pen- chung yew
extending ordinary inheritance schemes to include generalization  the arrangement of classes in a specialization hierarchy has proved to be a useful abstraction mechanism in class-based object oriented programming languages. the success of the mechanism is based on the high degree of code reuse that is offered, along with simple type conformance rules.  the opposite of specialization is generalization. we will argue that support of generalization in addition to specialization will improve class reusability. a language that only supports specialization requires the class hierarchy to be constructed in a top down fashion. support for generalization will make it possible to create super-classes for already existing classes, hereby enabling exclusion of methods and creation of classes that describe commonalties among already existing ones.  we will show how generalization can coexist with specialization in class-based object oriented programming languages. furthermore, we will verify that this can be achieved without changing the simple conformance rules or introducing new problems with name conflicts.  c. h. pedersen
subset/g pl/i and the pl/i standard  subset/g pl/i (g for general purpose) is a subset of full standard pl/i. both subset/g pl/i and standard pl/i are defined by standards issued by the american national standards institute. subset/g evolved in the late 1970's as a result of a growing realization that full pl/i was a remarkably effective (if much maligned) language but at the same time a difficult language to implement and to teach. subset/g was designed so as to preserve the most useful properties of pl/i while deleting features that were either little used, uneconomic to implement, or inappropriate to what we now know about good programming practice.  full standard pl/i is a descendant of the f-level pl/i language originally developed by ibm in the early 1960's. one of the design objectives of the original language was that it should be applicable to scientific programming, commercial programming, and systems programming. part of the original rationale for this objective was that pl/i was intended to replace fortran, cobol, and assembly language. but there was also another reason: the growing number of applications that spanned more than one category. subset/g also has this design objective, although some other design objectives of early pl/i were dropped, notably the principle that any construct that could reasonably be given a meaning should be acceptable. that rationale remains a major reason why subset/g is a significant and useful language despite the many other languages that have emerged since pl/i was first designed.  paul w. abrahams
a flexible semantic analyzer for ada  a technique for writing semantic analysis phases of compilers is described. the technique uses simula classes and virtual procedures to create a flexible and modular program.  this technique is used to implement a semantic analysis phase of a compiler front end for the preliminary ada language. because the design is extremely flexible and modular, the front end is able to accommodate changes in the ada language and its semantics as they are published.  several problems were encountered when implementing ada's semantics. these problems are described and their solutions presented.  the front end also produces tcolada, the specified intermediate language for various ada compiler contracts. this output has been used by an experimental compiler back end. [9]  the front end is written as two programs which perform lexical analysis, syntactic analysis, semantic analysis, and tcolada generation. the front end is coded in simula, and has been running on dec tops-10 and tops-20 systems since september 1979.  mark s. sherman martha s. borkan
algorithms for translating ada multitasking  algorithms are presented for translating the multitasking constructs of ada into the language ada-m. the purpose of the translation is to study various implementations of ada tasking and their relative problems, merits, and efficiencies. the multiprocessing constructs of ada-m are lower level than those of ada and, hence, flexible enough to permit development of a variety of compilation techniques for ada tasking. ada-m is sufficiently high-level, however, to permit the implementations to be developed quickly and understandably. requirements for data structures, scheduling, and other pertinant elements of ada tasking compilation are identified by the translation.  d. r. stevenson
the finnapl keyword editor  most terminals used do not support apl characters. although many microcomputers support soft fonts and some interpreters are equipped with a keyword option, and end-user apl applications should do without apl characters when in normal use, there still is a need for managing apl programming from terminals without apl characters. the authors propose a simple toolbox for the management of such situations in vm/sp environment.  juhani sandberg olli paavola tauno ylinen
a comparative study of coarse- and fine-grained safe regression test-selection techniques  regression test-selection techniques reduce the cost of regression testing by selecting a subset of an existing test suite to use in retesting a modified program. over the past two decades, numerous regression test-selection techniques have been described in the literature. initial empirical studies of some of these techniques have suggested that they can indeed benefit testers, but so far, few studies have empirically compared different techniques. in this paper, we present the results of a comparative empirical study of two safe regression test-selection techniques. the techniques we studied have been implemented as the tools dejavu and testtube; we compared these tools in terms of a cost model incorporating precision (ability to eliminate unnecessary test cases), analysis cost, and test execution cost. our results indicate, that in many instances, despite its relative lack of precision, testtube can reduce the time required for regression testing as much as the more precise dejavu. in other instances, particularly where the time required to execute test cases is long, dejavu's superior precision gives it a clear advantage over testtube. such variations in relative performance can complicate a tester's choice of which tool to use. our experimental results suggest that a hybrid regression test-selection tool that combines features of testtube and dejavu may be an answer to these complications; we present an initial case study that demonstrates the potential benefit of such a tool.  john bible gregg rothermel david s. rosenblum