waashk/acm huggingface dataset:
integrating the understanding of quality in requirements specification and conceptual modeling the notion of _quality_ of information system models and other conceptual models is not well understood. however, recent quality frameworks have tried to take a more systematic approach. we have earlier developed a framework for understanding and assessing the quality of models in general, with emphasis on models made in conceptual modeling languages. at the same time, there is a long tradition on discussing quality of more specialized models, e.g. in the form of requirements specifications. several authors have created taxonomies of useful properties of models and requirements specifications, the most comprehensive overview being presented by alan davis.we have in this paper extended our quality framework for models based on the work by davis on quality in requirement specifications, looking upon a requirements specification as a specific type of model. comparing the approaches we find on the one hand that the properties as summarized by davis are subsumed by our framework on a high level, and that there are aspects within our framework that are not covered by davis. on the other hand, the comparison has resulted in a useful extension and deepening of our framework on this specific kind of model, and in this way improved the practical applicability of our framework when applied to discussing the quality of requirements specifications. john krogstie
the multiway rendezvous  the multiway rendezvous is a natural generalization of the rendezvous in which more than two processes may participate. the utility of the multiway rendezvous is illustrated by solutions to a variety of problems. to make their simplicity apparent, these solutions are written using a construct tailor-made to support the multiway rendezvous. the degree of support for multiway rendezvous applications by several well-known languages that support the two- way rendezvous is examined. since such support for the multiway rendezvous is found to be inadequate, well-integrated extensions to these languages are considered that would help provide such support.  arthur charlesworth
the zark library of utility functions the primary appeal of apl has always been its _productivity._ you can develop and maintain computer applications faster with apl than with any other high-level programming language. apl has a number of distinct traits that contribute to this productivity advantage over other languages. however, language productivity is only one side of the programmer productivity triangle. the other two are programmer experience and utility software. the programmer with the most productive language, the most experience, and the best utility software will develop better code, and faster than the programmer who is deficient in any of these three areas. experienced apl programmers generally score well in the first two areas, but poorly in the third, probably because apl obviates the perceived need for high quality utility software. programmers in other languages do not have this luxury and so tend to develop and rely upon more extensive and higher quality utility software. consequently, the productivity advantage of apl programmers over other programmers is not as significant as it can be. zarklib, the zark library of utility functions, is a scheme that attempts to remedy this problem. it is both an extensive collection of apl utility software and a motivational scheme. it guarantees its growth and maintenance by employing a "pyramid" scheme that motivates apl programmers to give until it hurts, and then give again. gary a. bergquist
comparison of delivered reliability of branch, data flow and operational testing: a case study  many analytical and empirical studies of software testing effectiveness have used the probability that a test set exposes at least one fault as the measure of effectiveness. that measure is useful for evaluating testing techniques when the goal of testing is to gain confidence that the program is free from faults. however, if the goal of testing is to improve the reliability of the program (by discovering and removing those faults that are most likely to cause failures when the software is in the field) then the measure of test effectiveness must distinguish between those faults that are likely to cause failures and those that are unlikely to do so. delivered reliability was previously introduced as a means of comparing testing techniques in that setting. this paper empirically compares reliability delivered by three testing techniques, branch testing, the all-uses data flow testing criterion, and operational testing. the subject program is a moderate-sized c-program (about 10,000 loc) produced by professional programmers and containing naturally occurring faults.  phyllis g. frankl yuetang deng
from formal models to formally based methods: an industrial experience  we address the problem of increasing the impact of formal methods in the practice of industrial computer applications. we summarize the reasons why formal methods so far did not gain widespead use within the industrial environment despite several promising experiences. we suggest an evolutionary rather than revolutionary attitude in the introduction of formal methods in the practice of industrial applications, and we report on our long-standing experience which involves an academic institution. politecnico di milano, two main industrial partners, enel and cise, and occasionally a few other industries. our approach aims at augmenting an existing and fairly deeply rooted informal industrial methodology with our original formalism, the logic specification language trio. on the basis of the experiences we gained we argue that our incremental attitude toward the introduction of formal methods within the industry could be effective largely independently from the chosen formalism.  emanuele ciapessoni piergiorgio mirandola alberto coen- porisini dino mandrioli angelo morzenti
generating a test oracle from program documentation: work in progress  a fundamental assumption of software testing is that there is some mechanism, an oracle, that will determine whether or not the results of a test execution are correct. in practice this is often done by comparing the output, either automatically or manually, to some pre-calculated, presumably correct, output [17]. however, if the program is formally documented it is possible to use the specification to determine the success or failure of a test execution, as in [1], for example. this paper discusses ongoing work to produce a tool that will generate a test oracle from formal program documentation.  in [9], [10] and [11] parnas et al. advocate the use of a relational model for documenting the intended behaviour of programs. in this method, tabular expressions are used to improve readability so that formal documentation can replace conventional documentation. relations are described by giving their characteristic predicate in terms of the values of concrete program variables. this documentation method has the advantage that the characteristic predicate can be used as the test oracle -- it simply must be evaluated for each test execution (input & output) to assign pass or fail. in contrast to [1], this paper discusses the testing of individual programs, not objects as used in [1]. consequently, the method works with program documentation, written in terms of the concrete variables, and no representation function need be supplied. documentation in this form, and the corresponding oracle, are illustrated by an example.  finally, some of the implications of generating test oracles from relational specifications are discussed.  dennis peters david l. parnas
a model solution for the c3i domain  this paper1 briefly describes a specific portion of recent work performed by the domain specific software architecture (dssa) project at the software engineering institute (sei) --- the development and use of a model solution for message translation and validation in the c3i domain. based on this experience and our involvement with programs in the c3i domain, future considerations are described. these considerations involve identifying potential models within a domain and making recommendations for developing and documenting model solutions which will enable the models to be reused.  c. plinta k. lee
distributed real-time system specification and verification in aptl  in this article, we propose a language, asynchronous propositional temporal logic (aptl), for the specification and verification of distributed hard real- time sytems. aptl extends the logic tptl by dealing explicitly with multiple local clocks. we propose a distributed-system model which permits definition of inequalities asserting the temporal precedence of local clock readings. we show the expressiveness of aptl through two nontrivial examples. our logic can be used to specify and reason about such important properties as bounded clock rate drifting. we then give a 220(n) tableau-based decision procedure for determining aptl satisfiability, where n is the size (number of bits) of the input formula.  farn wang aloysius k. mok e. allen emerson
apl2os: design considerations for a nested array file system  apl2os is an external function for the apl2 system, designed to enable apl2 applications to access operating system files (and information about these files) in a straightforward and efficient way, using the power of apl2 syntax to maximum advantage. the design goals and approaches for apl2os are discussed, in the context of a summary of its features.  david m. weintraub
the design of an integrated, interactive and incremental programming environment  we are currently implementing a system to help experienced programmers during the development, implementation and debugging of their programs. this system, built on top of a screen oriented structural editor, offers possibilities of attaching descriptors to every portion of the program and to maintain - simultaneously - different versions of the program being written, including tentative hypothetical versions. it comprises a mecanism to maintain minimal consistency between modified parts of code, the non-modified parts of code and the attached descriptors, as well as an evaluation module functioning in different modes : normal evaluation, symbolic evaluation and checking evaluation.  the standard programming aids, such as indexors, pretty printers, trace packages, undo- and history-facilities are generalized to handle the descriptors and unfinished programs as well.  harald wertz
backtracking without trailing in clp ( rlin )  existing clp languages support backtracking by generalizing traditional prolog implementations: modifications to the constraint system are trailed and restored on backtracking. although simple and efficient, trailing may be very demanding in memory space, since the constraint system may potentially be saved at each choice point.  this article proposes a new implementation scheme for backtracking in clp languages over linear (rational or real) arithmetic. the new scheme, called semantic backtracking, does not use trailing but rather exploits the semantics of the constraints to undo the effect of newly added constraints. semantic backtracking reduces the space complexity compared to implementations based on trailing by making it essentially independent of the number of choice points. in addition, semantic backtracking introduces negligible space and time overhead on deterministic programs. the price for this improvement is an increase in backtracking time, although constraint-solving time may actually decrease. the scheme has been implemented as part of a complete clp system clp (rlin) and compared analytically and experimentally with optimized trailing implementations. experimental results on small and real-life problems indicate that semantic backtracking produces significant reduction in memory space, while keeping the time overhead reasonably small.  pascal van hentenryck viswanath ramachandran
locality in distributed computations  the defining characteristic of a distributed system is the (temporal) distance between components; communication time is non-trivial compared to processing time. because of this, the design of efficient distributed computations involves trade-offs between maximizing the amount of parallelism and minimizing communication costs. we argue that any sort of centralized control, whether in user-level algorithms or at the systems level, impairs efficiency. we then introduce a scheme for automatic process synchronization that meets our locality criterion.  david k. garnick a. toni cohen
exact analysis of the cache behavior of nested loops  we develop from first principles an exact model of the behavior of loop nests executing in a memory hicrarchy, by using a nontraditional classification of misses that has the key property of composability. we use presburger formulas to express various kinds of misses as well as the state of the cache at the end of the loop nest. we use existing tools to simplify these formulas and to count cache misses. the model is powerful enough to handle imperfect loop nests and various flavors of non-linear array layouts based on bit interleaving of array indices. we also indicate how to handle modest levels of associativity, and how to perform limited symbolic analysis of cache behavior. the complexity of the formulas relates to the static structure of the loop nest rather than to its dynamic trip count, allowing our model to gain efficiency in counting cache misses by exploiting repetitive patterns of cache behavior. validation against cache simulation confirms the exactness of our formulation. our method can serve as the basis for a static performance predictor to guide program and data transformations to improve performance.  siddhartha chatterjee erin parker philip j. hanlon alvin r. lebeck
message pattern specifications: a new technique for handling errors in parallel object oriented systems  as object oriented techniques enable the fabrication of ever more sophisticated systems, the need grows for a mechanism to ensure the consistent and 'correct' behaviour of each object at run-time. we describe a new, in- source specification mechanism, message pattern specifications (mps), to directly satisfy this need in a succinct, orthogonal and disciplined manner. targeted for use in parallel object oriented systems, mps allows programmers to enunciate the 'legal' patterns of run-time behaviour in which their objects may engage. furthermore, it supports the definition of methods for object recovery or graceful failure in case these specifications are violated during execution.  jan a. purchase russel l. winder
portable resource control in java preventing abusive resource consumption is indispensable for all kinds of systems that execute untrusted mobile coee, such as mobile object sytems, extensible web servers, and web browsers. to implement the required defense mechanisms, some support for resource control must be available: accounting and limiting the usage of physical resources like cpu and memory, and of logical resources like threads. java is the predominant implementation language for the kind of systems envisaged here, even though resource control is a missing feature on standard java platforms. this paper describes the model and implementation mechanisms underlying the new resource-aware version of the j-seal2 mobile object kernel. our fundamental objective is to achieve complete portability, and our approach is therefore based on java bytecode transformations. whereas resource control may be targeted towards the provision of quality of service or of usage-based billing, the focus of this paper is on security, and more specificlly on prevention of denial-of-service attacks orginating from hostile or poorly implemented mobile code. walter binder jane g. hulaas alex villazón
fp with data abstraction and strong typing  this paper begins by presenting arguments for including data abstraction and compile time type checking in functional programming languages, and discussing in general terms the mechanisms required to provide support for these features. it then goes on to present brief introductions to the algebraic style of formally specifying abstract data types and to the fp style of writing functional programs. the middle section describes a version of fp that includes type checking and data abstraction. the key to this is the development of a framework for describing the fp type system in terms of the already existing algebra of fp programs. the paper concludes with an example program illustrating the style of fp programming made possible by our extensions.  john guttag james horning john williams
toward a formal theory of extensible software as software projects continue to grow in scale and scope, it becomes important to reuse software. an important kind of reuse is _extensibility,_ i.e., the extension of software without accessing existing code to edit or copy it. in this paper, we propose a rigorous, semantics-based definition of software extensibility. then we illustrate the utility of our definitions by applying them to several programs. the examination shows how programming style affects extensibility and also drives the creation of a variant of an existing design pattern. we consider programs in both object-oriented and functional languages to prove the robustness of our definitions. shriram krishnamurthi matthias felleisen
analyzing stores and references in a parallel symbolic language  we describe an analysis of a parallel language in which processes communicate via first-class mutable shared locations. the sequential core of the language defines a higher-order strict functional language with list data structures. the parallel extensions permit processes and shared locations to be dynamically created; synchronization among processes occurs exclusively via shared locations.  the analysis is defined by an abstract interpretation on this language. the interpretation is efficient and useful, facilitating a number of important optimizations related to synchronization, processor/thread mapping, and storage management.  suresh jagannathan stephen weeks
an abstract machine for clp( r )  an abstract machine is described for the clp( r ) programming language. it is intended as a first step toward enabling clp( r ) programs to be executed with efficiency approaching that of conventional languages. the core constraint logic arithmetic machine (clam) extends the warren abstract machine (wam) for compiling prolog with facilities for handling real arithmetic constraints. the full clam includes facilities for taking advantage of information obtained from global program analysis.  joxan jaffar peter j. stuckey spiro michaylov roland h. c. yap
software testability: an experiment in measuring simulation reusability  software reuse can be more readily enabled if the testing of the code in the previous environment is still applicable to the new environment. the reusability of previous verification efforts is an important parameter is assessing the "immediate" reusability of the code; in this paper, the verification technique that we are focusing on is software testing. this paper presents the use of a software testability measure, sensitivity analysis, as a quantitative assessment of the reusability of previous verification. the ability to reuse verification is a factor to consider in determining the reusability of code. we have applied this technique to a large nasa supersonic software simulation, high speed civil transport (hsct), and the reusability results of that application suggest a possible concern about the sufficiency of the original verification.  j. voas j. payne r. mills j. mcmanus
assessing and enhancing software testing effectiveness although many techniques for testing software have been proposed over the last twenty years, there is still not enough solid evidence to indicate which (if any) of these techniques are effective. it is difficult to perform meaningful comparisons of the cost and effectiveness of testing techniques; in fact, even defining these terms in a meaningful way is problematic. consider an erroneous program _p,_ its specification _s,_ and a test data adequacy criterion _c_ (such as 100% branch coverage). even if we restrict the size of the test sets to be considered, there are a huge number of different test sets that satisfy criterion _c_ for _p_ and _s._ since these adequate test sets typically have different properties, in order to investigate effectiveness (or other properties) rigorously, the entire space of test sets must be considered (according to some reasonable probability distribution) and appropriate probabilistic analysis and/or statistical sampling techniques must be used.in earlier research, supported by nsf grant ccr-9206910, we developed analytical tools and an experiment design to address these issues and applied them to comparing a number of well-known testing techniques. the primary measure of effectiveness considered was probability that an adequate test set would detect at least one fault and the most of the experiment subjects were fairly small. the main thread of this research project extends that work in several directions: additional measures of cost and effectiveness are considered, analytical and experimental tools are developed for these measures, and experiments are conducted on larger programs.
bugs in the programs  security on the internet is receiving increasing attention as more and more organizations are becoming dependent on the network. the use of the internet for electronic commerce, government operations, research activities, and entertainment has now reached the point that attacks against the network and the systems connected to it have become major news items. while the press highlights a few high-profile incidents, the actual number of attacks is much higher. the cert coordination center works with the internet community to deal with incidents and responded to over 8,000 incidents in 1999. the incident projection for year 2000 is 17,000 to 20,000. at the same time, the amount of damage resulting from the incidents is also increasing. while the press often focuses on cases of web site graffiti, more serious cases of financial fraud, extortion, and debilitating denial of service attacks are being reported at increasing rates.  richard d. pethia
time-machine computing: a time-centric approach for the information environment  this paper describes the concept of time- machine computing (tmc), a time- centric approach to organizing information on computers. a system based on time-machine computing allows a user to visit the past and the future states of computers. when a user needs to refer to a document that he/she was working on at some other time, he/she can travel in the time dimension and the system restores the computer state at that time. since the user's activities on the system are automatically archived, the user's daily workspace is seamlessly integrated into the information archive. the combination of spatial information management of the desktop metaphor and time traveling allows a user to organize and archive information without being bothered by folder hierarchies or the file classification problems that are common in today's desktop environments. tmc also provides a mechanism for linking multiple applications and external information sources by exchanging time information. this paper describes the key features of tmc, a time-machine desktop environment called "timescape," and several time-oriented application integration examples.  jun rekimoto