waashk/acm huggingface dataset:
interactive design of structures: a program for everyone in this paper we present a program for the design and analysis of planar member frame structures. the intuitive graphic user interface covers all steps necessary for designing a load bearing structure, from geometry design to system optimization.this project is the first step in converting from a pool of apl*plus ii programs towards interactive windows applications written in dyalogapl/w, and was carried out by dipl.-ing. johann riebenbauer, institute of structural design (institut f r tragwerkslehre) at the technical university of graz, austria, and the group of civil engineering (ig f r bauwesen) zenkner&amp;handel.the; computational section of the described application is composed of proven space frame algorithms, which where developed by prof. peter klement over the last three decades in apl, and which represent the backbone of the new graphic user interface (gui) in dyalogapl/w. (in the appendix the reader can find a small vocabulary, which can be used to translate the german words in the illustrations.) johann riebenbauer joachim hoffmann
genericity versus inheritance reconsidered: self-reference using generics  as shown by the work of bertrand meyer, it is possible to simulate genericity using inheritance, but not vice-versa. this is because genericity is a parameterization mechanism with no way to deal with the polymorphic typing introduced using inheritance. nevertheless, if we focus on the use of inheritance as an implementation technique, its key feature is the dynamic binding of self-referential operation calls. this turns out to be basically a parameterization mechanism that can in fact be simulated using generics and static binding. and for some applications this approach may actually be of more than academic interest.  ed seidewitz
a bayesian differential debugging model for software reliability  an assumption commonly made in early models of software reliability is that the failure rate of a program is a constant multiple of the number of bugs remaining. this implies that all bugs have the same effect upon the overall failure rate. the assumption is challenged and an alternative proposed. the suggested model results in earlier bug-fixes having a greater effect than later ones (the worst bug show themselves earlier and so are fixed earlier), and the dfr properly between bug-fixes (confidence in programs increases during periods of failure-free operation, as well as at bug-fixes). the model shows a high degree of mathematical tractability, and allows a range of reliability, and allows a range of reliability measures to be calculated exactly. predictions of total execution time to achieve a target reliability, are obtained.  b. littlewood
a lisp machine  lisp is the second oldest computer-programming language still in active use. our implementation is based on a powerful microprogrammed processor designed specifically for lisp. this processor supports a tagged macro-architecture; it manipulates items which have a built- in data-type field.  the system supports several important new storage-management features, including a real-time garbage collector with hardware assist (using the basic algorithm of baker).  the software itself is written in lisp to a much larger extent than in previous systems. in fact, there are only two levels in which code is written: lisp and microcode. among other things this improves the consistancy of system interfaces.  the system design incorporates the personal computer philosophy. we believe the personal computer will predominate in the future since it is preferable to time-sharing in most cases and technological trends are greatly reducing its cost penality. in the case of very large programs, the personal computer can be cost-effective today, due to the phenomenon of thrashing encountered in time-sharing systems.  richard d. greenblatt thomas f. knight john t. holloway david a. moon
design of guis from a programming perspective  this paper presents a design method for graphical user interfaces. the method is based on semantic specification. based on formalized style rules and guidelines, a user interface design proposal is derived from the functionality of an application. the advantages of this method are: the automation of parts of the design process, automatic design evaluation, and automatic mapping to multiple user interface toolkits. the paper proposes a specification language for graphical user interfaces. this language will ease the transition from the functional design of an application to the user interface design by a semantically driven designer of user interfaces. the paper gives an ada example of the use of the language.  ole lauridsen
task concurrency management methodology to schedule the mpeg4 im1 player on a highly parallel processor platform  this paper addresses the concurrent task management of complex multi-media systems, like the mpeg4 im1 player, with emphasis on how to derive energy-cost _vs_ time- budget curves through task scheduling on a multi-processor platform. starting from the original "standard" specification, we extract the concurrency originally hidden by implementation decisions in a "grey-box" model. then we have applied two high-level transformations on this model to improve the task-level concurrency. finally, by scheduling the transformed task-graph, we have derived energy-cost _vs_ time-budget curves. these curves will be used to get globally optimized design decisions when combining subsystems into one complete system or to be used by a dynamic scheduler. the results on the mpeg4 im1 player confirm the validity of our assumptions and the usefulness of our approach.  chun wong paul marchal peng yang
programming languages and systems for prototyping concurrent applications  concurrent programming is conceptually harder to undertake and to understand than sequential programming, because a programmer has to manage the coexistence and coordination of multiple concurrent activities. to alleviate this task several high-level approaches to concurrent programming have been developed. for some high-level programming approaches, prototyping for facilitating early evaluation of new ideas is a central goal.  prototyping is used to explore the essential features of a proposed system through practical experimentation before its actual implementation to make the correct design choices early in the process of software development. approaches to prototyping concurrent applications with very high-level programming systems intend to alleviate the development in different ways. early experimentation with alternate design choices or problem decompositions for concurrent applications is suggested to make concurrent programming easier.  this paper presents a survey of programming languages and systems for prototyping concurrent applications to review the state of the art in this area. the surveyed approaches are classified with respect to the prototyping process.  wilhelm hasselbring
towards a compiler front-end for ada  this paper discusses the current development of a compiler front-end for ada at the university of karlsruhe. the front-end is independent of the target- machine and will compile ada into an intermediate language aida, essentially an attributed structure tree. the front-end is written in its own language using ada-0 and lis as preliminary compilers for the bootstrap. the compiler in its present form relies heavily on the formal definition of ada which is under development at cii and iria.  gerhard goos georg winterstein
output from generic packages ada83 suffers from being a non-polymorphic statically bound language in that, the types of data need to be known before run-time. the generic mechanism helps to overcome this limitation in that a non-type specific package can be written and instantiated for several actual data types, depending on the generic formal parameter chosen. one problem that is not solved by the generic mechanism is that of input and output of data values. since actual data types are represented in different ways, there is no single routine which can be called upon to get or put items of a generic formal type. this paper outlines a possible solution to this problem. paul slater
the design of a virtual machine for ada  an implementation of ada should be based on a machine-independent translator generating code for a virtual machine, which can be realised on a variety of machines. this approach, which leads to a high degree of compiler portability, has been very successful in a number of recent language implementation projects and is the approach which has been specified by the u.s. army and air force in their requirements for ada implementations.  this paper discusses the rationale, requirements and design of such a virtual machine for ada. the discussion concentrates on a number of fundamental areas in which problems arise: basic virtual machine structure, including storage structure and addressing; data storage and manipulation; flow of control; subprograms, blocks and exceptions; and task handling.  l. j. groves w. j. rogers
code generation for fixed-point dsps  this paper examines the problem of code-generation for digital signal processors (dsps). we make two major contributions. first, for an important class of dsp architectures, we propose an optimal o(n) algorithm for the tasks of register allocation and instruction scheduling for expression trees. optimality is guaranteed by sufficient conditions derived from a structural representation of the processor instruction set architecture (isa). second, we develop heuristics for the case when basic blocks are directed acyclic graphs (dags).  guido araujo sharad malik
dynamically displaying a pascal program in color  this paper describes a method of using color to display the actual structure of a pascal program on a color monitor. this enhancement not only increases a programmer's understanding of the code, but also aids in detecting common structural errors. the paper identifies several structures deserving of color and the properties that must be adhered to when assigning colors to these structures. a simple coloring scheme illustrates this discussion. the last section describes enhancements and directions for future research.  john f. cigas
a methodology for controlling the size of a test suite  this paper presents a technique to select a representative set of test cases from a test suite that provides the same coverage as the entire test suite. this selection is performed by identifying, and then eliminating, the redundant and obsolete test cases in the test suite. the representative set replaces the original test suite and thus, potentially produces a smaller test suite. the representative set can also be used to identify those test cases that should be rerun to test the program after it has been changed. our technique is independent of the testing methodology and only requires an association between a testing requirement and the test cases that satisfy the requirement. we illustrate the technique using the data flow testing methodology. the reduction that is possible with our technique is illustrated by experimental results.  m. jean harrold rajiv gupta mary lou soffa
as strong as possible mobility (poster session)  an executing thread, in an object oriented programming language, is spawned, directly or indirectly, by a main process. this in turn gets its instructions from a primary class. in java there is no close coupling of a thread and the objects from which they were created. the use of a container abstraction allows us to group threads and their respective objects into a single structure. a container that holds threads whose variables are all housed within the container is a perfect candidate for strong migration. to achieve this we propose a combination of three techniques to allow the containers to migrate in a manner that approaches strong mobility yet does not resort to retaining bindings to resources across distant and unreliable networks.  tim walsh paddy nixon simon dobson
practical uses of operators in sharp apl/hp  at apl86 in manchester, the language features of sharp apl/hp on a hewlett packard range of minicomputers were introduced in a paper written by this author, entitled 'apl procedures (user defined operators, functions and token strings)'. this is the first of several papers which have been planned to supplement this introductory work. the models of several new and existing operators are described in detail, all of which may be directly executed in sharp apl/hp. the models take advantage of various features of sharp apl/hp including extended assignment and procedure arrays [1] (often referred to as function arrays in their most common form). the paper will pursue a comparison of the less general implementation of operators in apl2, with special reference to ed eusebi's pioneering work in the field of 'operators for program control and recursion' [2 3], wherein an alternative definition for several of these operators will be proposed. the paper will then proceed to describe 'operators applying to enclosed arrays' (for example a pervasive operator) and various 'mathematical operators' (instances of which are the power and transitive closure operators), always highlighting these models with examples of their practical application.  robert hodgkinson
a highly integrated tool set for program development support  this paper describes the design of the integrated user interface of the software development environment ipsen (integrated programming support environment). we explain the characteristic features of the ipsen user interface, namely the structured layout of the screen, the command-driven tool activation, and especially the highly integrated use of the ipsen tool set. we demonstrate those features by taking a sample set of tools of the ipsen environment. that tool set supports all the programming-in-the-small activities within ipsen. finally, we sketch the realization of two prototypes running on an ibm-at and a net of sun workstations.  gregor engels thorsten janning wilhelm schäfer
mode: a uims for smalltalk  while the model-view-controller (mvc) framework has contributed to many aspects of user interface development in smalltalk, interfaces produced with mvc often have highly coupled model, view, and controller classes. this coupling and the effort required to use mvc make user interface creation a less effective aspect of smalltalk.  the mode development environment (mode) is a user interface management system (uims) which addresses the above issues. mode is composed of two major components: the mode framework and the mode composer. the mode framework accommodates an orthogonal design which decouples the user interface components and increases their reusability. the mode composer reduces the effort of using mode by providing a direct-manipulation user interface to its users. this paper discusses the importance of orthogonality and illustrates its incorporation into the design of mode. a comparison of the mode framework and the mvc framework is included.  yen-ping shan
using predicate abstraction to reduce object-oriented programs for model checking  while it is becoming more common to see model checking applied to software requirements specifications, it is seldom applied to software implementations. the automated software engineering group at nasa ames is currently investigating the use of model checking for actual source code, with the eventual goal of allowing software developers to augment traditional testing with model checking. because model checking suffers from the state-explosion problem, one of the main hurdles for program model checking is reducing the size of the program. in this paper we investigate the use of abstraction techniques to reduce the state-space of a real-time operating system kernel written in c++. we show how informal abstraction arguments could be formalized and improved upon within the framework of predicate abstraction, a technique based on abstract interpretation. we introduce some extensions to predicate abstraction that all allow it to be used within the class-instance framework of object-oriented languages. we then demonstrate how these extensions were integrated into an abstraction tool that performs automated predicate abstraction of java programs.  william visser seungjoon park john penix
an automatic object-oriented parser generator for ada although many parser generator tools (aka compiler compilers) are available, very few create a parse tree. instead, the user must add actions to the grammar to create the parse tree. this is a tedious, mechanical task, which could easily be automated. we propose a simple scheme to map a grammar to an object-oriented hierarchy, and provide a tool, called adagoop, that creates lexer and parser specifications complete with all of the actions necessary to create the parse tree. martin c. carlisle
integrating noninterfering versions of programs  the need to integrate several versions of a program into a common one arises frequently, but it is a tedious and time consuming task to integrate programs by hand. to date, the only available tools for assisting with program integration are variants of text-based differential file comparators; these are of limited utility because one has no guarantees about how the program that is the product of an integration behaves compared to the programs that were integrated.  this paper concerns the design of a semantics-based tool for automatically integrating program versions. the main contribution of the paper is an algorithm that takes as input three programs a, b, and base, where a and b are two variants of base. whenever the changes made to base to create a and b do not "interfere" (in a sense defined in the paper), the algorithm produces a program m that integrates a and b. the algorithm is predicated on the assumption that differences in the behavior of the variant programs from that of base, rather than differences in the text, are significant and must be preserved in m. although it is undecidable whether a program modification actually leads to such a difference, it is possible to determine a safe approximation by comparing each of the variants with base. to determine this information, the integration algorithm employs a program representation that is similar (although not identical) to the dependence graphs that have been used previously in vectorizing and parallelizing compilers. the algorithm also makes use of the notion of a program slice to find just those statements of a program that determine the values of potentially affected variables.  the program-integration problem has not been formalized previously. it should be noted, however, that the integration problem examined here is a greatly simplified one; in particular, we assume that expressions contain only scalar variables and constants, and that the only statements used in programs are assignment statements, conditional statements, and while-loops.  susan horwitz jan prins thomas reps
calculation and use of an environment's characteristic software metric set  since both cost/quality goals and production environments differ, this study presents an approach for customizing a characteristic set of software metrics to an environment. the approach is applied in the software engineering laboratory (sel), a nasa goddard production environment, to 49 candidate process and product metrics of 652 modules from six (51,000 - 112,000 line) projects. for this particular environment, the method yielded the characteristic metric set {source lines, fault correction effort per executable statement, design effort, code effort, number of i/o parameters, number of versions}. the uses examined for a characteristic metric set include forecasting the effort for development, modification, and fault correction of modules based on historical data.  victor r. basili richard w. selby
on the conversion of indirect to direct recursion  procedure inlining can be used to convert mutual recursion to direct recursion. this allows use of optimization techniques that are most easily applied to directly recursive procedures, in addition to the well-known benefits of inlining. we present tight (necessary and sufficient) conditions under which inlining can transform all mutual recursion to direct recursion, and those under which heuristics to eliminate mutual recursion always terminate. we also present a technique to eliminate mutually recursive circuits that consist of only tail calls. from this, we conclude that tail recursion elimination should be interleaved with inlining.  owen kaser c. r. ramakrishnan shaunak pawagi
operating-system directed power reduction  this paper presents a new approach for power reduction by taking a global, software-centric view. it analyzes the sources of power consumption: tasks that require services from hardware components. when a component is not used by any task, it can enter a sleeping state to save power. operating systems have detailed information about tasks; therefore, os is the best place for identifying hardware idleness and shutting down unused components. we implement this technique in linux and show that it can save more than 50% power compared to traditional hardware- centric shutdown techniques.  yung-hsiang lu luca benini giovanni de micheli
using partial-order methods in the formal validation of industrial concurrent programs we have developed a formal validation tool that has been used on several projects that are developing software for at&amp;t;'s 5ess telephone switching system. the tool uses holzmann's supertrace algorithm to check for errors such as deadlock and livelock in networks of communicating processes. the validator invariably finds subtle errors that were missed during thorough simulation and testing; however, the brute-force search it performs can result in extremely long running times, which can be frustrating to users. recently, a number of researchers have been investigating techniques known as _partial- order methods_ that can significantly reduce the running time of formal validation by avoiding redundant exploration of execution scenarios. in this paper, we describe the design of a partial-order algorithm for our validation tool and discuss its effectiveness. we show that a careful compile-time static analysis of process communication behavior yields information that can be used during validation to dramatically improve its performance. we demonstrate the effectiveness of our partial-order algorithm by presenting the results of experiments with actual industrial examples drawn from a variety of 5ess application domains, including call processing, signalling, and switch maintenance. patrice godefroid doron peled mark staskauskas
a study of locking objects with bimodal fields  object locking can be efficiently implemented by bimodal use of a field reserved in an object. the field is used as a lightweight lock in one mode, while it holds a reference to a heavyweight lock in the other mode. a bimodal locking algorithm recently proposed for java achieves the highest performance in the absence of contention, and is still fast enough when contention occurs.  however, mode transitions inherent in bimodal locking have not yet been fully considered. the algorithm requires busy-wait in the transition from the light mode (inflation), and does not make the reverse transition (deflation) at all.  we propose a new algorithm that allows both inflation without busy-wait and deflation, but still maintains an almost maximum level of performance in the absence of contention. we also present statistics on the synchronization behavior of real multithreaded java programs, which indicate that busy-wait in inflation and absence of deflation can be problematic in terms of robustness and performance. actually, an implementation of our algorithm shows increased robustness, and achieves performance improvements of up to 13.1% in server- oriented benchmarks.  tamiya onodera kiyokuni kawachiya