waashk/acm huggingface dataset:
the fujaba environment  however, a single collaboration diagram is usually not expressive enough to model complex operations performing several modifications at different parts of the overall object structure. such series of modifications need several collaboration diagrams to be modeled. in addition, there may be different situations where certain collaboration diagrams should be executed and others not. thus, we need additional control structures to control the execution of collaboration diagrams. in our approach we combine collaboration diagrams with statecharts and activity diagrams for this purpose. this means, instead of just pseudo code, any state or activity may contain a collaboration diagram modeling the do-action of this step.  figure 1 illustrates the main concepts of fujaba. fujaba uses a combination of statecharts and collaboration diagrams to model the behavior of active classes. a combination of activity diagrams and collaboration diagrams models the bodies of complex methods. this integration of class diagrams and uml behavior diagrams enables fujaba to perform a lot of static analysis work facilitating the creation of a consistent overall specification. in addition, it turns these uml diagrams into a powerful visual programming language and allows to cover the generation of complete application code.  during testing and maintenance the code of an application may be changed on the fly, e.g. to fix small problems. some application parts like the graphical user interface or complex mathematical computations may be developed with other tools. in cooperative (distributed) software development projects some developers may want to use fujaba, others may not. code of different developers may be merged by a version management tool. there might already exist a large application and one wants to use fujaba only for new parts. one may want to do a global search-and-replace to change some text phrases. one may temporarily violate syntactic code structures while she or he restructures some code. for all these reasons, fujaba aims to provide not just code generation but also the recovery of uml diagrams from java code. one may analyse (parts of) the application code, recover the corresponding uml diagram (parts), modify these diagram (parts), and generate new code (into the remaining application code). so far, this works reasonable for class diagrams and to some extend for the combination of activity and collaboration diagrams. for statecharts this is under development.  the next chapters outline the (forward engineering) capabilities of fujaba with the help of an example session.  ulrich nickel jörg niere albert zundorf
selective specialization for object-oriented languages  dynamic dispatching is a major source of run-time overhead in object-oriented languages, due both to the direct cost of method lookup and to the indirect effect of preventing other optimizations. to reduce this overhead, optimizing compilers for object-oriented languages analyze the classes of objects stored in program variables, with the goal of bounding the possible classes of message receivers enough so that the compiler can uniquely determine the target of a message send at compile time and replace the message send with a direct procedure call. specialization is one important technique for improving the precision of this static class information: by compiling multiple versions of a method, each applicable to a subset of the possible argument classes of the method, more precise static information about the classes of the method's arguments is obtained. previous specialization strategies have not been selective about where this technique is applied, and therefore tended to significantly increase compile time and code space usage, particularly for large applications. in this paper, we present a more general framework for specialization in object-oriented languages and describe a goal directed specialization algorithm that makes selective decisions to apply specialization to those cases where it provides the highest benefit. our results show that our algorithm improves the performance of a group of sizeable programs by 65% to 275% while increasing compiled code space requirements by only 4% to 10%. moreover, when compared to the previous state- of-the-art specialization scheme, our algorithm improves performance by 11% to 67% while simultaneously reducing code space requirements by 65% to 73%.  jeffrey dean craig chambers david grove
slicing concurrent programs  slicing is a well-known program analysis technique for analyzing sequential programs and found useful in debugging, testing and reverse engineering. this paper extends the notion of slicing to concurrent programs with shared memory, interleaving semantics and mutual exclusion. interference among concurrent threads or processes complicates the computation of slices of concurrent programs. further, unlike slicing of sequential programs, a slicing algorithm for concurrent programs needs to differentiate between loop-independent data dependence and certain loop- carried data dependences.  we show why previous methods do not give precise solutions in the presence of nested threads and loops and describe our solution that correctly and efficiently computes precise slices. though the complexity of this algorithm is exponential on the number of threads, a number of optimizations are suggested. using these optimizations, we are able to get near linear behavior for many practical concurrent programs.  mangala gowri nanda s. ramesh
design principles behind chiron: a uims for software environments  user interface facilities are a crucial part of the infrastructure of a software environment. we discuss the particular demands and constraints on a user interface management system (uims) for a software environment, and the relation between the architecture of the environment and the uims. a model for designing user interface management systems for large, extensible environments is presented. this model synthesizes several recent advances in user interfaces and specializes them to the domain of software environments. the model can be applied to a wide variety of environment contexts. a prototype implementation is described.  m. young r. n. taylor d. b. troup c. d. kelly
high-level language facilities for low-level services  ez is a language-based programming environment that offers the services provided separately by programming languages and operating systems in traditional environments. these services are provided as facilities of a high- level string processing language with a 'persistent' memory in which values exist indefinitely or until changed. in ez, strings and associative tables provide traditional file and directory services. this paper concentrates on the use of ez procedures and their activations, which, like other values, have indefinite lifetimes. in ez, the low-level aspects of procedure execution, such as activation record creation, references to local variables, and access to state information, are accessible via high-level language constructs. as a result, traditionally distinct services can be provided by a single service in the ez environment. furthermore, such services can be written in ez itself. an editor/debugger that illustrates the details of this approach is described.  christopher w. fraser david r. hanson
benefits of a data flow-aware programming environment many programmers write their programs with a primitive text editor that has no knowledge about the edited text. on the other hand, they use ingenious compilers that collect control flow and data flow information to perform optimizations and generate optimized code. we argue that program editors should have the same knowledge about the control flow and data flow of a program. such editors could help programmers to better understand programs and to be more productive. we propose a data flow-aware programming environment that makes the information that the compiler already computed visible. the bidirectional feedback from the compiler to the programmer and back from the programmer to the compiler enables productive programming and faster debugging. christoph steindl
compiler technology evaluation  the ada compiler evaluation capability (acec) is a u.s. government sponsored evaluation suite that was first released in the fall of 1988. it consists of over 1000 runtime performance tests and is under continuing development to address additional evaluation concerns. currently, the government is developing procedures and guidelines to make the collection and reporting of evaluation data a more systematic and formal process. the compiler technology evaluation panel will address the current status of evaluation technology, and the prospects for improving both compiler technology and the compiler selection process through formal evaluation procedures.  the panel will be comprised of four panelists and an "acec procedures/guidelines" presenter. the four panelists will consist of two ada compiler developers, a defense contractor, and a government program representative selected for their knowledge, experience, and different perspectives of ada compiler evaluation. the presenter will be an ajpo representative who will be providing the current status on the intended use and procedures of the acec. this presenter will also serve as a panelist during the question and answer period.  the panel is meant to promote discussion and provide insight into embedded systems ada compiler quality/usability especially as it relates to current and proposed evaluation tests and procedures. to facilitate this discussion, in addition to the acec presentation, each of the four panelists have been requested to respond to the following three questions:  what is the current overall quality of embedded system ada compilers targeted for "bare" processors? answers should consider the following:  code generation - correctness, time and space efficiency  runtime system - correctness, time and space efficiency, configurability, and interfacing capability  implementation dependent features for efficiency and their impact on portability  compiler support for good symbolic information  ability to interface with other software integration tools  robustness (freedom from errors) and user interface  < ;item>  what is the current overall quality of the acec for evaluating ada compilers for "bare" processors? answers should consider the following:  coverage of major evaluation areas  size - number of tests  ease of use and degree of automation  analysis tools and the ability to synthesize results  soundness of the methodolog y  remembe ring that language conformity is a critical quality parameter, what has been the impact of the acvc (test and procedures) on ada compiler quality? what is and/or what will be the impact of the acec (tests and procedures) on ada compiler quality?  d. smith n. weiderman
introspection: a register transfer level technique for cocurrent error detection and diagnosis in data dominated designs we report a register transfer level technique for concurrent error detection and diagnosis in data dominated designs called _introspection_. introspection uses idle computation cyles in the data path and idle data transfer cycles in the interconnection network in a synergistic fashion for concurrent error detection and diagnosis (cedd). the resulting on-chip fault latencies are one ten-thousandth (10-4) of previously reported system level concurrent error detection and diagnosis latencies. the associated area overhead and performance penalty are negligible. we derive a cost function that considers introspection constraints such as (i) executing an operation on three disjoint function units for diagnosis and (ii) promoting function units to participate in at least one cedd operation. we formulate integration of introspection constraints into the operation-to-operator binding phase of high-level synthesis as a weighted bipartite matching problem. the effectiveness of introspection and its implementation are illustrated on numerous industrial strength benchmarks. ramesh karri balakrishnan iyer
commercial realtime software needs different configuation management  arguments are presented as to why integrated, monolithic configuration management is not well suited to commercial realtime systems. an alternative approach to configuration management that over several years we have found to be effective and widely useable is described. this approach, database and selectors cel (dasc), separates treatment of versions that exist simultaneously from the evolution of those versions over time. versions that exist simultaneously are represented by selectors from a common database. evolution is represented by layers, as in the film animators cel.  w. m. gentleman a. mackay d. a. stewart
convolutional bound hierarchies  the time required to find the exact solution of a product-form queueing network model of a computer system can be high. faster and cheaper methods of solution, such as approximations, are natural alternatives. however, the errors incurred when using an approximation technique should be bounded.  several recent techniques have been developed which provide solution bounds. these bounding techniques have the added benefit that the bounds can be made tighter if extra computational effort is expended. thus, a smooth tradeoff of cost and accuracy is available. these techniques are based upon mean value analysis. in this paper a new bounding technique based upon the convolution algorithm is presented. it provides a continuous range of cost versus accuracy tradeoffs for both upper and lower bounds. the bounds produced by the technique converge to the exact solution as the computational effort approaches that of convolution. also, the technique may be used to improve any existing set of bounds.  lindsey e. stephens lawrence w. dowdy
ada conformity assessments: a model for other programming languages? this paper presents the actual status of ada conformity assessments after the transition of ada conformity assessments from the ada joint program office to iso. the principles of ada conformity assessments according to the iso/iee final committee draft 18009 are summarized and the commonalties and differences to the previous practices are discussed. in the main part of the work conformity assessments for ada c, c++, and java are compared. it is shown that the process as practiced with ada is unique compared to other programming languages. this can be understood by looking at the special culture of the language ada and its validation system. both were sponsored by one single party (the us dod) and not the it industry. the paper concludes with an assessment and outlook on the future development on compiler conformity assessments in general. michael tonndorf
1/k phase stamping for continuous shared data (extended abstract)  interactive distributed applications are a relatively new class of applications that are enabled by sharing continuously evolving data across distributed sites (and users). the characteristics of application data include very fine-grained updates that can atomically access a subset of the shared data, masking of update effects, and irregular locality and contention for access. existing programming approaches are not appropriate for programming such continuous shared data in a wide-area environment.  we define an object-set abstraction, where a set is replicated at sites interested in the objects, and is modified using add, delete and update operations. the key features of this abstraction are issue-time access information for update operations, and the potential for replicating the computation associated with updates. ordering of operations is an important problem, and we present a fast, scalable ordering algorithm, 1/k phase stamping, that uses distributed tokens that correspond to objects in the set. this algorithm provides substantially better performance than alternative algorithms, is deadlock and abort free, and requires no queuing at the tokens. therefore, tokens can be located inside a programmable 'active' network. the precise stamps generated with 1/k phase stamping enable a dynamic communication optimization technique, effect and stamp merging, which can reduce communication and allow utilization of best-effort message delivery. these algorithms have been implemented in the raga system which can tolerate crash failures.  sumeer bhola mustaque ahamad
implementation of resilient, atomic data types  a major issue in many applications is how to preserve the consistency of data in the presence of concurrency and hardware failures. we suggest addressing this problem by implementing applications in terms of abstract data types with two properties: their objects are atomic (they provide serializability and recoverability for activities using them) and resilient (they survive hardware failures with acceptably high probability). we define what it means for abstract data types to be atomic and resilient. we also discuss issues that arise in implementing such types, and describe a particular linguistic mechanism provided in the argus programming language.  william weihl barbara liskov
on-the-fly detection of access anomalies  access anomalies are a common class of bugs in shared-memory parallel programs. an access anomaly occurs when two concurrent execution threads both write (or one thread reads and the other writes) the same shared memory location without coordination. approaches to the detection of access anomalies include static analysis, post- mortem trace analysis, and on-the-fly monitoring.  a general on-the-fly algorithm for access anomaly detection is presented, which can be applied to programs with both nested fork-join and synchronization operations. the advantage of on-the-fly detection over post- mortem analysis is that the amount of storage used can be greatly reduced by data compression techniques and by discarding information as soon as it becomes obsolete. in the algorithm presented, the amount of storage required at any time depends only on the number v of shared variables being monitored and the number n of threads, not on the number of synchronizations. data compression is achieved by the use of two techniques called merging and subtraction. upper bounds on storage are shown to be v × n2 for merging and v × n for subtraction.  d. schonberg
japanese language handling in apl environments while japan is amongst the first countries to use apl back in the early 1970's and enjoyed at one time as high as 40% of ibm main-frame customers using apl, the lack of japanese language support of apl in popular computing environments today such as unix/aix, os/2 and windows seems to be driving apl out of the scene.this paper tries to bring up this subject more officially than i have done in the past for more public discussion not only for japan, but also for those countries, where the characters required by national languages cannot be contained in the ascii table of 256 codes. kyosuke saigusa
in black and white: an integrated approach to class-level testing of object- oriented programs  because of the growing importance of object- oriented programming, a number of testing strategies have been proposed. they are based either on pure black-box or white-box techniques. we propose in this article a methodology to integrate the black- and white-box techniques. the black-box technique is used to select test cases. the white-box technique is mainly applied to determine whether two objects resulting from the program execution of a test care are observationally equivalent. it is also used to select test cases in some situations. we define the concept of a fundamental pair as a pair of equivalent terms that are formed by replacing all the variables on both sides of an axiom by normal forms. we prove that an implementation is consistent with respect to all equivalent terms if and only if it is consistent with respect to all fundamental pairs. in other words, the testing coverage of fundamental pairs is as good as that of all possible term rewritings, and hence we need only concentrate on the testing of fundamental pairs. our strategy is based on mathematical theorems. according to the strategy, we propose an algorithm for selecting a finite set of fundamental pairs as test cases. given a pair of equivalent terms as a test case, we should then determine whether the objects that result from executing the implemented program are observationally equivalent. we prove, however, that the observational equivalence of objects cannot be determined using a finite set of observable contexts (which are operation sequences ending with an observer function) derived from any black-box technique. hence we supplement our approach with a "relevant observable context" technique, which is a heuristic white-box technique to select a relevant finite subset of the set of observable contexts for determining the observational equivalence. the relevant observable contezxts are constructed from a data member relevance graph (drg), which is an abstraction of the given implementation for a given specificatin. a semiautomatic tool hass been developed to support this technique.  huo yan chen t. h. tse f. t. chan t. y. chen
making active case tools - toward the next generation case tools in case field, there is a long-standing topic, i.e. the reason that case tools seem to be dearly bought but sparsely used. based on our practical experience of making and using case tools, we point out the reason is that today's case tools are actually not very much user-oriented. the factors and requirements of case users are not given enough consideration in the production of case tools. most today's case tools are motivated by new paradigms and techniques in the area of software engineering. therefore, making case tools are often driven by techniques, rather than by real users' needs and expectations. in this paper, we present our viewpoints on the reason why case tools are used below expectations. we suggest some important features that are worthy of careful consideration while producing more people-oriented and active case tools. we also describe some strategies for building such case tools. riri huang
extending attribute grammars to support programming-in-the-large  attribute grammars add specification of static semantic properties to context- free grammars, which, in turn, describe the syntactic structure of program units. however, context-free grammars cannot express programming-in- the-large features common in modern programming languages, including unordered collections of units, included units, and sharing of included units. we present extensions to context-free grammars, and corresponding extensions to attribute grammars, suitable for defining such features. we explain how batch and incremental attribute-evaluation algorithms can be adapted to support these extensions, resulting in a uniform approach to intraunit and interunit static semantic analysis and translation of multiunit programs.  josephine micallef gail e. kaiser
marvel strategy language example  the docprep environment was developed by two students, laura johnson and victor kan, as their term project in the spring 1989 e6123y programming environments and software tools course. neither student had any prior knowledge of or experience with marvel, and were not familiar with its internal implementation. they successfully used docprep to produce their final project report. the twelve envelopes, bind, delete- sect-order, format, printdoc, printsec, review-format-err, review-spell-err, runeditor, specify- header, specify-printer, specify-sect-order and spell- check, are omitted.  gail e. kaiser