waashk/acm huggingface dataset:
a concurrency analysis tool suite for ada programs: rationale, design, and preliminary experience  cats (concurrency analysis tool suite) is designed to satisfy several criteria: it must analyze implementation-level ada source code and check user- specified conditions associated with program source code; it must be modularized in a fashion that supports flexible composition with other tool components, including integration with a variety of testing and analysis techniques; and its performance and capacity must be sufficient for analysis of real application programs. meeting these objectives together is significantly more difficult than meeting any of them alone. we describe the design and rationale of cats and report experience with an implementation. the issues addressed here are primarily practical concerns for modularizing and integrating tools for analysis of actual source programs. we also report successful application of cats to major subsystems of a (nontoy) highly concurrent user interface system.  michal young richard n. taylor david l. levine kari a. nies debra brodbeck
extended application of ada to cover ecbs with o4s: ecbs = engineering ofcomputer based systems; o4s = objects for systemsthe system concept is presented as a structure constituted from objects fromthe categories mission, operator, software and hardware. it is shown how ada'ssemantics and syntax can be used in the pseudo language odel to describesystem structure and object behaviour, regardless of object category.experience form 10 years of ada-based methods work has led to an understandingof the evolutionary and iterative nature of systems work, expressed in the o4smethod with its "ball- bearing" development model. it is shown how the methodmakes it possible to unify system and project structure and thus optimizeproject resource utilization.application areas for the o4s are shown concentrating on system developmentwith cooperation between users and developers.ingmar Ã-gren
considered harmful - still the apl character set has contributed, more than any other facet of the language, to its lack of acceptance in the computing community at large. the character set is a metaproblem---not a problem in and of itself, but a creator of other recurring problems of hardware, software, ergonomics, and psychology. the adoption of new, ascii-based dialects of apl, such as j, is suggested as one solution to the character-set problem. robert bernecky
gidts: a graphical programming environment for prolog this paper puts forward the graphical interactive diagnosing, testing and slicing system (_gidts_) which is a graphical programming environment for prolog programs. the _idts_part of the system integrates shapiro's interactive diagnosis algorithm with the category partition testing method (_cpm_) and a slicing technique performing the _algorithmic debugging_ and _functional testing_ of prolog programs. the integration of _idts_ with a graphical user interface (_gui_) supports the whole functionality of _idts_ and provides a user-friendly environment giving the user more information on the state of the debugging process. _gidts_ extends _idts_ to a complete programming environment. it allows one to handle the debugging of complex programs using the _extended_ syntax and semantics of prolog in a very flexible way. a static code diagnosis has also been implemented. in addition _gidts_ supports debugging-directed editing of the source program, and a quick source code navigation via any of the tools (for example: the debugger, the static call graph and the information retriever). all these features are supported by the graphical user interface. gabriella kókai jörg nilson christian niss
strong typing and physical units  this paper proposes a syntactic extension of high level languages like pascal or ada to allow the usage of physical quantities, i.e. numbers with units, instead of just numbers. it offers enhanced type checking for expressions and assignments during compilation time. additionally, it allows problem oriented simple scaling of variables and local scale selection. furthermore, it reduces the number of coding errors due to wrongly chosen scales. after a discussion of mutual relations between strong typing in programming languages and physical units, examples are shown to demonstrate the usefulness of the proposed extension. finally a graph representation of the new syntactic elements is given.  r. männer
polymorphic splitting: an effective polyvariant flow analysis  this article describes a general-purpose program analysis that computes global control-flow and data-flow information for higher-order, call-by-value languages. the analysis employs a novel form of polyvariance called polymorhic splitting that uses let-expressions as syntactic clues to gain precision. the information derived from the analysis is used both to eliminate run-time checksand to inline procedure. the analysis and optimizations have been applied to a suite of scheme programs. experimental results obtained from the prototype implementation indicate that the analysis is extremely precise and has reasonable cost. compared to monovariantflow analyses such as 0cfa, or analyses based on type inference such as soft typing, the analysis eliminates significantly more run-time checks. run-time check elimination and inlining together typically yield a 20 to 40% performance improvement for the benchmark suite, with some programs running four times as fast.  andrew k. wright suresh jagannathan
implications of apl2 grammar  a subtle but pervasive feature of apl2 is its new way of describing syntax. it is based on an ordered list of ordered pairs of syntactic classes. position in the list corresponds to the strength of the syntactic bond between objects of the classes in the pair. the single rule of execution is to scan from the right until the binding drops and then evaluate the pair of objects just scanned.  the new simple view of syntax suggests some straightforward extensions to the language which do not complicate the syntax and address such areas as:  specifying a variable number of iterations of each in a manner analogous to the way a power operator can specify iterations of a function.  using similar and similarly simple expressions to apply structural functions and operators, for example (2 3 )″ a b c and (2 3 /)″ a b c require, respectively, that the named objects be of rank 2 and of length 2 (after scalar extension). the first expression is, of course, not valid today; the second is, and the parentheses are redundant.  creating arrays of objects other than data, a subject treated in several papers in recent years  a number of identities involving functions and operators, including some which provide compact notation for concepts of elementary arithmetic.  the elevators of landaeta, which are only possible if a language contains identically structured expressions for objects of different symbolic classes, provide a way of describing analogues of an operation in different syntactic classes. these lead to an interesting new diagrammatic way of expressing identities.  j. philip benkard
using types to analyze and optimize object-oriented programs  object- oriented programming languages provide many software engineering benefits, but these often come at a performance cost. object-oriented programs make extensive use of method invocations and pointer dereferences, both of which are potentially costly on modern machines. we show how to use types to produce effective, yet simple, techniques that reduce the costs of these features in modula-3, a statically typed, object-oriented language. our compiler performs type-based alias analysis to disambiguate memory references. it uses the results of the type-based alias analysis to eliminate redundant memory references and to replace monomorphic method invocation sites with direct calls. using limit, static, and running time evaluation, we demonstrate that these techniques are effective, and sometimes perfect for a set of modula-3 benchmarks.  amer diwan kathryn s. mckinley j. eliot b. moss
an integrated compile-time/run-time software distributed shared memory system on a distributed memory machine, hand-coded message passing leads to the most efficient execution, but it is difficult to use. parallelizing compilers can approach the performance of hand-coded message passing by translating data- parallel programs into message passing programs, but efficient execution is limited to those programs for which precise analysis can be carried out. shared memory is easier to program than message passing and its domain is not constrained by the limitations of parallelizing compilers, but it lags in performance. our goal is to close that performance gap while retaining the benefits of shared memory. in other words, our goal is (1) to make shared memory as efficient as message passing, whether hand-coded or compiler- generated, (2) to retain its ease of programming, and (3) to retain the broader class of applications it supports.to this end we have designed and implemented an integrated compile-time and run-time software dsm system. the programming model remains identical to the original pure run-time dsm system. no user intervention is required to obtain the benefits of our system. the compiler computes data access patterns for the individual processors. it then performs a source-to-source transformation, inserting in the program calls to inform the run-time system of the computed data access patterns. the run-time system uses this information to aggregate communication, to aggregate data and synchronization into a single message, to eliminate consistency overhead, and to replace global synchronization with point-to-point synchronization wherever possible.we extended the parascope programming environment to perform the required analysis, and we augmented the treadmarks run-time dsm library to take advantage of the analysis. we used six fortran programs to assess the performance benefits: jacobi, 3d-fft, integer sort, shallow, gauss, and modified gramm-schmidt, each with two different data set sizes. the experiments were run on an 8-node ibm sp/2 using user-space communication. compiler optimization in conjunction with the augmented run-time system achieves substantial execution time improvements in comparison to the base treadmarks, ranging from 4% to 59% on 8 processors. relative to message passing implementations of the same applications, the compile-time run-time system is 0-29% slower than message passing, while the base run-time system is 5-212% slower. for the five programs that xhpf could parallelize (all except is), the execution times achieved by the compiler optimized shared memory programs are within 9% of xhpf. sandhya dwarkadas alan l. cox willy zwaenepoel
essential c++ c++ is rapidly becoming one of the most important programming languages in the world. yet it is an extremely complex language and, therefore, one that is very difficult to learn. to provide a significant degree of simplification and, thereby, to help alleviate the difficulties of learning the language, a relatively small c++ subset, essential c++, has been defined. it is proposed for use by the computer science academic community as a suitable first programming language for students as well as for use by other individuals who desire eventually to become software developers using the full c++ language.after supporting the case for the need of a c++ subset and discussing the reasons for developing one, this article presents essential c++, provides the rationale for selecting its particular constituents from the full c++ language, and then examines the advantages and disadvantages of using essential c++. jarrell c. grout robert g. strader john b. hanks
compiler and runtime support for out-of-core hpf programs  this paper describes the design of a compiler which can translate out-of-core programs written in a data parallel language like hpf. such a compiler is required for compiling large scale scientific applications, such as the grand challenge applications, which deal with enormous quantities of data. we propose a framework by which a compiler together with appropriate runtime support can translate an out-of-core hpf program to a message passing node program with explicit parallel i/o. we describe the basic model of the compiler and the various transformations made by the compiler. we also discuss the runtime routines used by the compiler for i/o and communication. in order to minimize i/o, the runtime support system can reuse data already fetched into memory. the working of the compiler is illustrated using two out-of-core applications, namely a laplace equation solver and lu decomposition, together with performance results on the intel touchstone delta.  rajeev thakur rajesh bordawekar alok choudhary
semantic errors - diagnosis and repair  in compiler technology, semantic error handling has too often used ad hoc techniques and terse messages of fixed content. in contrast, we present general models of diagnosis and repair of semantic errors and illustrate their use in the york ada workbench compiler. the diagnostic model focuses upon the problem of selecting suitable information from which the programmer can locate and correct an error; following a brief discussion of an approach in which filters are applied to reports, and we give a more extensive account of a new approach using an interactive diagnostic interpreter. the repair model is based upon the idea of plastic nodes which are introduced into the compiler's internal representation of a program to replace normal nodes which are missing or erroneous.  c w johnson c runciman
a dynamic scheduling method for irregular parallel programs  this paper develops a methodology for compiling and executing irregular parallel programs. such programs implement parallel operations whose size and work distribution depend on input data. we show a fundamental relationship between three quantities that characterize an irregular parallel computation: the total available parallelism, the optimal grain size, and the statistical variance of execution times for individual tasks. this relationship yields a dynamic scheduling algorithm that substantially reduces the overhead of executing irregular parallel operations.  we incorporated this algorithm into an extended fortran compiler. the compiler accepts as input a subset of fortran d which includes blocked and cyclic decompositions and perfect alignment; it outputs fortran 77 augmented with calls to library routines written in c. for irregular parallel operations, the compiled code gathers information about available parallelism and task execution time variance and uses this information to schedule the operation. on distributed memory architectures, the compiler encodes information about data access patterns for the runtime scheduling system so that it can preserve communication locality.  we evaluated these compilation techniques using a set of application programs including climate modeling, circuit simulation, and x-ray tomography, that contain irregular parallel operations. the results demonstrate that, for these applications, the dynamic techniques described here achieve near-optimal efficiency on large numbers of processors. in addition, they perform significantly better, on these problems, than any previously proposed static or dynamic scheduling algorithm.  steven lucco
frequency counts, accumulations and cross-tabulations in apl frequency counts (how many) and accumulations (how much) are everyday programming tasks. yet, there are no primitive apl functions for solving these problems directly. instead, you dig into your bag of techniques and use some clever shifting or inner/outer product method to do the job. this paper proposes a primitive syntax for generally computing frequency counts, accumulations and cross- tabulations (which are multidimensional frequency counts and accumulations). the aim of the paper is not to encourage the implementation of a new primitive function; rather, it offers a mental model: a way to view this class of problems. a user-defined function that implements the model is shown on page 28\. gary a. bergquist
a third-generation self implementation: reconciling responsiveness with performance  programming systems should be both responsive (to support rapid development) and efficient (to complete computations quickly). pure object-oriented languages are harder to implement efficiently since they need optimization to achieve good performance. unfortunately, optimization conflicts with interactive responsiveness because it tends to produce long compilation pauses, leading to unresponsive programming environments. therefore, to achieve good responsiveness, existing exploratory programming environments such as the smalltalk-80 environment rely on interpretation or non-optimizing dynamic compilation. but such systems pay a price for their interactiveness, since they may execute programs several times slower than an optimizing system.  self-93 reconciles high performance with responsiveness by combining a fast, non-optimizing compiler with a slower, optimizing compiler. the resulting system achieves both excellent performance (two or three times faster than existing smalltalk systems) and good responsiveness. except for situations requiring large applications to be (re)compiled from scratch, the system allows for pleasant interactive use with few perceptible compilation pauses. to our knowledge, self-93 is the first implementation of a pure object- oriented language achieving both good performance and good responsiveness.  when measuring interactive pauses, it is imperative to treat multiple short pauses as one longer pause if the pauses occur in short succession, since they are perceived as one pause by the user. we propose a definition of pause clustering and show that clustering can make an order-of- magnitude difference in the pause time distribution.  urs hölzle david ungar
reducing the storage requirements of constraint dataflow graphs  most one-way constraint solvers use directed dataflow graphs to represent the dependencies among variables in a constraint. unfortunately, dataflow graphs require a great deal of storage. these storage costs can help push a large application into virtual memory, thus significantly degrading interactive performance. reducing the storage costs of dataflow graphs is therefore an important goal in constraint research. this paper describes a study that makes two contributions to solving this problem:  bradley t. vander zanden richard l. halterman
taccle: a methodology for object-oriented software testing at the class and cluster levels  object-oriented programming consists of several different levels of abstraction, namely, the algorithmic level, class level, cluster level, and system level. the testing of object-oriented software at the algorithmic and system levels is similar to conventional program testing. testing at the class and cluster levels poses new challenges. since methods and objects may interact with one another with unforeseen combinations and invocations, they are much more complex to simulate and test than the hierarchy of functional calls in conventional programs. in this paper, we propose a methodology for object-oriented software testing at the class and cluster levels. in class- level testing, it is essential to determine whether objects produced from the execution of implemented systems would preserve the properties defined by the specification, such as behavioral equivalence and nonequivalence. our class- level testing methodology addresses both of these aspects. for the testing of behavioral equivalence, we propose to select fundamental pairs of equivalent ground terms as test cases using a black-box technique based on algebraic specifications, and then determine by means of a white-box technique whether the objects resulting from executing such test cases are observationally equivalent. to address the testing of behavioral nonequivalence, we have identified and analyzed several nontrivial problems in the current literature. we propose to classify term equivalence into four types, thereby setting up new concepts and deriving important properties. based on these results, we propose an approach to deal with the problems in the generation of nonequivalent ground terms as test cases. relatively little research has contributed to cluster-level testing. in this paper, we also discuss black-box testing at the cluster level. we illustrate the feasibility of using contract, a formal specification language for the behavioral dependencies and interactions among cooperating objects of different classes in a given cluster. we propose an approach to test the interactions among different classes using every individual message-passing rule in the given contract specification. we also present an approach to examine the interactions among composite message-passing sequences. we have developed four testing tools to support our methodology.  huo yan chen t. h. tse t. y. chen
commonloops: merging lisp and object-oriented programming  commonloops blends object-oriented programming smoothly and tightly with the procedure-oriented design of lisp. functions and methods are combined in a more general abstraction. message passing is invoked via normal lisp function call. methods are viewed as partial descriptions of procedures. lisp data types are integrated with object classes. with these integrations, it is easy to incrementally move a program between the procedure and object-oriented styles.  one of the most important properties of commonloops is its extensive use of meta- objects. we discuss three kinds of meta-objects: objects for classes, objects for methods, and objects for discriminators. we argue that these meta- objects make practical both efficient implementation and experimentation with new ideas for object-oriented programming.  commonloops' small kernel is powerful enough to implement the major object- oriented systems in use today.  daniel g. bobrow kenneth kahn gregor kiczales larry masinter mark stefik frank zdybel
systematic object-oriented inspection - an empirical study  _software inspection is recognised as an effective defect detection technique, but research has suggested that its performance on object-oriented code may suffer as a result of the delocalised nature of the software. this leads to problems of how to segment a system into chunks, what reading strategy should be adopted to read those chunks, and how to make available necessary non-local information. this paper presents the results of an empirical investigation that compared a systematic, abstraction-driven inspection reading technique with an ad-hoc approach in an attempt to investigate these issues._  _the analysis shows that using the systematic technique does not significantly improve an inspector's overall defect detection performance. the systematic technique does, however, seem to have potential to help address delocalisation through the creation of abstract specifications, encourage a deeper understanding of the code being inspected, and may also help discover different defects from an ad-hoc approach. there was also positive feedback from inspectors for the rigour imposed by the systematic technique._  _this research suggests that a systematic, abstraction-driven reading strategy offers some potential but there are issues that need to be addressed in terms of supporting the efficient construction of abstractions and dealing with the differences between the static and dynamic views of object-oriented code._  alastair dunsmore marc roper murray wood