waashk/acm huggingface dataset:
new ideas for generic components in ada the creation of reusable software components is an important part of modern software practice. generic templates are one technique for designing these components. a generic template is a module containing algorithms which can operate on some class of data types where the specific data type is not known until later in the development process. many languages, including ada, support this technique. in ada, generic templates must be type-safe at compile time. we examine some features of ada which allow us to define the type as an entire package module and to instantiate with that module. the main theme of this paper will be generic formal package parameters. richard riehle
procol: a protocol-constrained concurrent object-oriented language  procol is a simple concurrent object-oriented language supporting a distributed, incremental and dynamic object environment. its communication is based on unidirectional messages. objects are only bound during actual message transfer and not during the processing of the message. this short duration object binding promotes parallelism. the communication leading to access has o obey an explicit protocol in each object. it takes the form of a specification of the occurrence and sequencing of the interaction between the object and its communication partners. the use of such protocols fosters structured, safer and potentially verifiable communication between objects.  j. van den bos
working with xml  xml (extensible mark up language) is fast becoming a standard method for data organization, structure, and exchange on the internet. the extensibility of xml allows web authors to create their own markup for any type of information. this extensibility is mobilizing the science and industry to customize xml for different fields such as mathematics (mathml), and business (xbrl). in this tutorial we will create an on-line multiple choice test in xml while discussing the xml syntax and its validation techniques. we will also present different methods for formatting, displaying and manipulating xml documents inside a browser. the tutorial will end with a discussion of the current status of xml.  ali m. farahani
convivial error recovery  this paper presents a new approach to an event control mechanism (ecm) for apl. after an informal review of some typical ecm implementations, it describes the general architecture of an ecm and shows how the mentioned implementations map onto it. an extended ecm is then presented that combines many features of existing implementations with some new capabilities. it gives the user access to the immediate context of the subexpression where an error occurred and introduces new control functions to allow execution to move to a determined calling environment. the proposed additions aim at a "convivial" utilization of the ecm suitable both to automatic control and to interactive debugging of apl applications.  denis samson yves ouellet
experience with commonloops  commonloops is an object-oriented language embedded in common lisp. it is one of two such languages selected as starting points for the common lisp object system (clos) which is currently being designed as a standard object-oriented extension to common lisp. this paper reports on experiences using the existing portable commonloops (pcl) implementation of commonloops. the paper is divided into two parts: a report on the development of a window system application using the commonloops programming language, and a description of the implementation of another object-oriented language (commonobjects) on top of the commonloops metaclass kernel, paralleling the two aspects of commonloops: the programming language and the metaclass kernel. usage of the novel features in commonloops is measured quantitatively, and performance figures comparing commonloops, commonobjects on commonloops, and the native lisp implementation of commonobjects are presented. the paper concludes with a discussion about the importance of quantitative assessment for programming language development.  james kempf warren harris roy d'souza alan snyder
surpassing the tlb performance of superpages with less operating system support  many commercial microprocessor architectures have added translation lookaside buffer (tlb) support for superpages. superpages differ from segments because their size must be a power of two multiple of the base page size and they must be aligned in both virtual and physical address spaces. very large superpages (e.g., 1mb) are clearly useful for mapping special structures, such as kernel data or frame buffers. this paper considers the architectural and operating system support required to exploit medium-sized superpages (e.g., 64kb, i.e., sixteen times a 4kb base page size). first, we show that superpages improve tlb performance only after invasive operating system modifications that introduce considerable overhead.  we then propose two subblock tlb designs as alternate ways to improve tlb performance. analogous to a subblock cache, a complete-subblock tlb associates a tag with a superpage-sized region but has valid bits, physical page number, attributes, etc., for each possible base page mapping. a partial-subblock tlb entry is much smaller than a complete-subblock tlb entry, because it shares physical page number and attribute fields across base page mappings. a drawback of a partial-subblock tlb is that base page mappings can share a tlb entry only if they map to consecutive physical pages and have the same attributes. we propose a physical memory allocation algorithm, page reservation, that makes this sharing more likely. when page reservation is used, experimental results show partial-subblock tlbs perform better than superpage tlbs, while requiring simpler operating system changes. if operating system changes are inappropriate, however, complete-subblock tlbs perform best.  madhusudhan talluri mark d. hill
quantifying software quality  in software quality assurance the quality of the program must be defined in practical and measurable terms. this is accomplished by first standardizing the error reporting technique, identifying the types and frequency of occurrence of software errors experienced, and finally, predicting the error arrival rate of the software programs. this paper details a practical approach to quantifying software quality by investigating empirical software error data. software failure trend analysis and residual error predictions are the by-products of this technique. successfully applied to software engineering projects, the author reports on the findings and details an implementation plan.  kenneth s. hendis
prioritizing test cases for regression testing  test case prioritization techniques schedule test cases in an order that increases their effectiveness in meeting some performance goal. one performance goal, rate of fault detection, is a measure of how quickly faults are detected within the testing process; an improved rate of fault detection can provide faster feedback on the system under test, and let software engineers begin locating and correcting faults earlier than might otherwise be possible. in previous work, we reported the results of studies that showed that prioritization techniques can significantly improve rate of fault detection. those studies, however, raised several additional questions: (1) can prioritization techniques be effective when aimed at specific modified versions; (2) what tradeoffs exist between fine granularity and coarse granularity prioritization techniques; (3) can the incorporation of measures of fault proneness into prioritization techniques improve their effectiveness? this paper reports the results of new experiments addressing these questions.  sebastian elbaum alexey g. malishevsky gregg rothermel
prolog compared with lisp  this is a report on a very concrete experiment to compare the relative speeds of dec-10 prolog (edinburgh implementation) and dec-10 lisp (texas implementation of uci-lisp, or tlisp). the comparison was made on the occasion of programming a theorem prover for the propositional calculus, natural- deduction type. the prover is complicated enough so as to try sufficiently sophisticated weaponry of each language, yet simple enough for the human eye to follow both programs in parallel and make sure that they are accomplishing very much the same thing.  the experiment was not undertaken with the direct intention of determining the relative performances of the two languages in general, but with the more specific goal of providing a basis for choosing a language for a large research project. nevertheless, the results are interesting enough so as to make us consider them worth divulging, especially because they seem to contradict the notion, repeatedly argued for by prolog advocates, that performances of the two languages are similar in relation to speed.  claudio gutierrez
a dynamic optimization framework for a java just-in-time compiler the high performance implementation of java virtual machines (jvm) and just-in-time (jit) compilers is directed toward adaptive compilation optimizations on the basis of online runtime profile information. this paper describes the design and implementation of a dynamic optimization framework in a production-level java jit compiler. our approach is to employ a mixed mode interpreter and a three level optimizing compiler, supporting quick, full, and special optimization, each of which has a different set of tradeoffs between compilation overhead and execution speed. a lightweight sampling profiler operates continuously during the entire program's exectuion. when necessary, detailed information on runtime behavior is collected by dynmiacally generating instrumentation code which can be installed to and uninstalled from the specified recompilation target code. value profiling with this instrumentation mechanism allows fully automatic code specialization to be performed on the basis of specific parameter values or global data at the highest optimization level. the experimental results show that our approach offers high performance and a low code expansion ratio in both program startup and steady state measurements in comparison to the compile-only approach, and that the code specialization can also contribute modest performance improvement toshio suganuma toshiaki yasue motohiro kawahito hideaki komatsu toshio nakatani
a high-level programming and command language  unifying programming and command languages is a promising idea that has yet to be thoroughly exploited. most attempts at such unification have used lisp or traditional languages, such as pascal. this paper describes the command and programming language ez, which attempts to unify command and programming languages by using high-level string-processing concepts, such as those in snobol4 and icon. ez has particularly simple data abstractions that attempt to bridge the gap between the data abstractions of command languages and those of programming languages. this is accomplished by type fusion, which pushes the differences between some classes of types, such as strings and text files, out of the language and into the implementation. the language, its use, and its implementation are described.  christopher w. fraser david r. hanson
field analysis: getting useful and low-cost interprocedural information  we present a new limited form of interprocedural analysis called  field analysis that can be used by a compiler to reduce the costs of modern language features such as object-oriented programming,automatic memory management, and run-time checks required for type safety.unlike many previous interprocedural analyses, our analysis is cheap, and does not require access to the entire program. field analysis exploits the declared access restrictions placed on fields in a modular language (e.g. field access modifiers in java) in order to determine useful properties of fields of an object.  we describe our implementation of field analysis in the swiftoptimizing compiler for java, as well a set of optimizations thatexploit the results of field analysis. these optimizations include removal of run-time tests, compile-time resolution of method calls, object inlining, removal of unnecessary synchronization, and stack allocation. our results demonstrate that field analysis is efficient and effective. speedups average 7% on a wide range of applications, with some times reduced by up to 27%. compile time overhead of field analysis is about 10%.  sanjay ghemawat keith h. randall daniel j. scales
microcomputers and multi-tasking machine control  microcomputers offer the world of machine control an unequaled tool in providing flexible control of large and complicated machines. traditionally a microcomputer is alloted for each machine to be controlled thereby massing several microcomputers. however, factors such as economic considerations or logistics may force a designer to stretch a microcomputer beyond its traditional capacities. a method of providing concurrent control of multiple machines using a single uni-tasking microcomputer system is investigated. the investigation is founded upon a working system, designed and built for the usda-ars soils laboratory in morris, minnesota. the analysis, therefore, has a certain practical flair to it that can be found useful for other projects where multiple tasks need to be handled simultaneously.  anthony a. kempka
using java reflection to automate extension language parsing  an extension language is an interpreted programming language designed to be embedded in a domain-specific framework. the addition of domain-specific primitive operations to an embedded extension language transforms that vanilla extension language into a domain-specific language. the luxworks processor simulator and debugger from lucent uses tcl as its extension language. after an overview of extension language embedding and luxworks experience, this paper looks at using java reflection and related mechanisms to solve three limitations in extension language - domain framework interaction. the three limitations are gradual accumulation of ad hoc interface code connecting an extension language to a domain framework, over-coupling of a domain framework to a specific extension language, and inefficient command interpretation.  java reflection consists of a set of programming interfaces through which a software module in a java system can discover the structure of classes, methods and their associations in the system. java reflection and a naming convention for primitive domain operations eliminate ad hoc interface code by supporting recursive inspection of a domain command interface and translation of extension language objects into domain objects. java reflection, name-based dynamic class loading, and a language-neutral extension language abstraction eliminate language over- coupling by transforming the specific extension language into a runtime parameter. java reflection and command objects eliminate inefficiency by bypassing the extension language interpreter for stereotyped commands. overall, java reflection helps to eliminate these limitations by supporting reorganization and elimination of handwritten code, and by streamlining interpretation.  dale parson
copy elimination in functional languages  copy elimination is an important optimization for compiling functional languages. copies arise because these languages lack the concepts of state and variable; hence updating an object involves a copy in a naive implementation. copies are also possible if proper targeting has not been carried out inside functions and across function calls. targeting is the proper selection of a storage area for evaluating an expression. by abstracting a collection of functions by a target operator, we compute targets of function bodies that can then be used to define an optimized interpreter to eliminate copies due to updates and copies across function calls. the language we consider is typed lambda calculus with higher-order functions and special constructs for array operations. our approach can eliminate copies in divide and conquer problems like quicksort and bitonic sort that previous approaches could not handle.  we also present some results of implementing a compiler for a single assignment language called sal on some small but tough programs. our results indicate that it is possible to approach a performance comparable to imperative languages like pascal.  k. gopinath j. l. hennessy
an experimental evaluation of simple methods for seeding program errors  this paper describes an experiment in which simple syntactic alterations were introduced into program text in order to evaluate the testing strategy known as error seeding. the experiment's goal was to determine if randomly placed syntactic manipulations can produce failure characteristics similar to those of indigenous errors found within unseeded programs. as a result of a separate experiment, several programs were available, all of which were written to the same specifications and thus were intended to be functionally equivalent. the use of functionally equivalent programs allowed the influence of individual programmer styles to be removed as a variable from the error seeding experiment. each of six different syntactic manipulations were introduced into each program and the mean times to failure for the seeded errors were observed. the seeded errors were found to have a broad spectrum of mean times to failure independent of the syntactic alteration used. we conclude that it is possible to seed errors using only simple syntactic techniques that are arbitrarily difficulty to locate. in addition, several unexpected results indicate that some issues involved in error seeding have not been addressed previously.  john c. knight paul e. ammann
an extended form of must alias analysis for dynamic allocation  the paper presents methods that we have implemented to improve the quality of the def-uses reported for dynamically allocated locations. the methods presented are based on the ruggieri/murtagh naming scheme for dynamically created locations. we expand upon this scheme to name dynamically allocated locations for some user written allocation routines. using this expanded naming scheme, we introduce an inexpensive, non-iterative, and localized calculation of extended must alias analysis to handle dynamically allocated locations, and show how this information can be used to improve def-use information. this is the first attempt to specify must alias information for names which represent a set of dynamically allocated locations. empirical results are presented to illustrate the usefulness of our method. we consider this work a step towards developing practical re- engineering tools for c.  rita z. altucher william landi
an interactive source commenter for prolog programs  prolog meta- circular interpreters, i.e., interpreters for prolog written in prolog, perform at least two operations on an object program - they parse it and execute its instructions. there is a useful variant of the meta-circular interpreter, the meta-circular parser, which as its name suggests, parses an object program without executing its instructions. the value of such a parser is that it provides an elegant means to modify prolog source code. as the object program is parsed, new information in the form of additional instructions, comments, etc., can be selectively inserted.  the prolog source code commenter we describe is a meta-circular parser with facilities added to allow a user to interactively enter comments. as a prolog program is parsed into its basic components, the user is allowed to view that component and enter an appropriate comment. the result is a new fully commented (and formatted) source program.  david roach hal berghel john r. talburt
object-oriented programming: an objective sense of style  we introduce a simple, programming language independent rule (known in-house as the law of demeter ) which encodes the ideas of encapsulation and modularity in an easy to follow form for the object-oriented programmer. you tend to get the following related benefits when you follow the law of demeter while minimizing simultaneously code duplication, the number of method arguments and the number of methods per class: easier software maintenance, less coupling between your methods, better information hiding, narrower interfaces, methods which are easier to reuse, and easier correctness proofs using structural induction. we discuss two important interpretations of the law (strong and weak) and we prove that any object-oriented program can be transformed to satisfy the law. we express the law in several languages which support object-oriented programming, including flavors, smalltalk-80, clos, c++ and eiffel.  k. lieberherr i. holland a. riel
communication between ada programs in diadem  it has been recognized for some time that ada is not well designed for the purpose of programming networks of loosely-coupled processors, and numerous projects have been set up to find a solution. the diadem project had the particular goal of constructing flexible ada programs that could be executed in a range of distributed systems, including, as a limiting case, a centralized uniprocessor. to this end a technique was developed by which the ada rendezvous could be used as a remote communication mechanism, supported in a highly portable way on a range of different network architectures and communication systems. this was achieved by the definition of a special package providing a "standard interface" to the transport layer services of the host communication system. after outlining the basic principles of the diadem approach, and describing the first prototype implementation of the communication mechanism, this paper discusses how a standard interface similar to that used in diadem could provide an efficient, yet portable, technique for supporting remote communication in time-critical (hard) real-time, distributed systems.  c. atkinson s. j. goldsack
from uml to java, building a 3-tier architecture: case study  the successful use of object technology requires far more than simply the adoption of a modern software technology or notation such as uml, java, corba or com. what is crucial, is knowing how to use these technologies to build commercially robust software systems. in this session the speaker draws on his experience at nasa, at&amp;t;, ibm, nova gass, and other leading companies to illustrate the pitfalls and best practices of component based software development.  timothy d. korson
algebraic software architecture reconfiguration  the ability of reconfiguring software architectures in order to adapt them to new requirements or a changing environment has been of growing interest, but there is still not much formal work in the area. most existing approaches deal with run-time changes in a deficient way. the language to express computations is often at a very low level of specification, and the integration of two different formalisms for the computations and reconfigurations require sometimes substantial changes. to address these problems, we propose a uniform algebraic approach with the following characteristics.  components are written in a high-level program design language with the usual notion of state.  the approach combines two existing frameworks---one to specify architectures, the other to rewrite labelled graphs---just through small additions to either of them.  it deals with certain typical problems such as guaranteeing that new components are introduced in the correct state (possibly transferred from the old components they replace).  it shows the relationships between reconfigurations and computations while keeping them separate, because the approach provides a semantics to a given architecture through the algebraic construction of an equivalent program, whose computations can be mirrored at the architectural level.  michel wermelinger jose luiz fiadeiro