waashk/dblp huggingface dataset:
regression test selection for aspectj software. as aspect-oriented software development gains popularity, there is growing interest in using aspects to implement cross-cutting concerns in object-oriented systems. when aspect-oriented features are added to an object-oriented program, or when an existing aspect-oriented program is modified, the new program needs to be regression tested to validate these changes. to reduce the cost of regression testing, a regression-test-selection technique can be used to select only a necessary subset of test cases to rerun. unfortunately, existing approaches for regression test selection for object-oriented software are not effective in the presence of aspectual information woven into the original code. this paper proposes a new regression-test-selection technique for aspectj programs. at the core of our approach is a new control-flow representation for aspectj software which captures precisely the semantic intricacies of aspect-related interactions. based on this representation, we develop a novel graph comparison algorithm for test selection. our experimental evaluation shows that, compared to existing approaches, the proposed technique is capable of achieving significantly more precise test selection.
residual test coverage monitoring. structural coverage criteria are often used as an indicator of the thoroughness of testing, but complete satisfaction of a criterion is seldom achieved. when a software product is released with less than 100% coverage, testers are explicitly or implicitly assuming that executions satisfying the remaining test obligations (the residue) are either infeasible or occur so rarely that they have negligible impact on quality. violation of this assumption indicates shortcomings in the testing process. monitoring in the deployed environment, even in the beta test phase, is typically limited to error and sanity checks. monitoring the residue of test coverage in actual use can provide additional useful information, but it is unlikely to be accepted by users unless its performance impact is very small. experience with a prototype tool for residual test coverage monitoring of java programs suggests that, at least for statement coverage, the simple strategy of removing all probes except those corresponding to the residue of coverage testing reduces execution overhead to acceptably low levels.
recording the reasons for design decisions. we outline a generic model for representing design deliberation and the relation between deliberation and the generation of method-specific artifacts. a design history is regarded as a network consisting of artifacts and deliberation nodes. artifacts represent specifications or design documents. deliberation nodes represent issues, alternatives or justifications. existing artifacts give rise to issues about the evolving design, an alternative is one of several positions that respond to the issue (perhaps calling for the creation or modification of an artifact), and a justification is a statement giving the reasons for and against the related alternative. the model is applied to the development of a text formatter. the example necessitates some tailoring of the generic model to the method adopted in the development, liskov and guttag's design method. we discuss the experiment and the method-specific extensions. the example development has been represented in hypertext and as a prolog database, the two representations being shown to complement each other. we conclude with a discussion of the relation between this model and other work, and the implications for tool support and methods.
kongsberg's road to an industrial software methodology. kongsberg våpenfabrikk, norway, has been engaged in establishing an up-to-date software engineering facility since late 1976.
discrete event simulation as a means of validating jsd design specifications. it is difficult to visualize the behaviour of an embedded system in its operational environment from a specification of the system alone. however, it is unacceptable to wait for system completion before validating its behaviour. discrete event simulation is an effective technique for making quantitative predictions about system behaviour, provided that the model is derived carefully from the system specification. we summarize the steps involved in deriving an ada** simulation program from a jsd function step specification, using a lift system as an illustration. having used this technique, we conclude that while it is time-consuming and not amenable to automation in the near future, it is cost-effective because it helps to elucidate counter-intuitive interactions between system functions and environmental parameters.
a formal approach for designing corba based applications. the design of distributed applications in a corba based environment can be carried out by means of an incremental approach, which starts from the specification and leads to the high level architectural design. this is done by introducing in the specification all typical elements of corba and by providing a methodological support to the designers. the paper discusses a methodology to transform a formal specification written in trio into a high level design document written using an extension of trio named tc. the tc language is suited to formally describe the high level architecture of a corba based application. the methodology and the associated language are presented by means of an example involving a real supervision and control system.
an algorithm to support code-skeleton generation for concurrent systems. computers are increasingly being used in engineering systems which could utilize a multiplicity of processors. computer aided design methods are needed to support the design of inherently complex concurrent software. ucla's sara (system architects apprentice) is a design environment which provides computer aid to both hardware and software design of concurrent systems. this paper focusses on an improved capability to aid software design. this capability is provided by defining a module interface description (mid), which allows designers to deal with the structure of code, and effecting a mapping between sara models and mid-models. it then becomes clear how to create a tool to accept these descriptions and perform various checks on the consistency and completeness of the modeling and implementation descriptions. the addition of this capability reduces the gap between the modeling and realization of systems by providing for automatic generation of code skeletons.
verification of time partitioning in the deos scheduler kernel. this paper describes an experiment to use the spin model checking system to support automated verification of time partitioning in the honeywell deos real-time scheduling kernel. the goal of the experiment was to investigate whether model checking could be used to find a subtle implementation error that was originally discovered and fixed during the standard formal review process. to conduct the experiment, a core slice of the deos scheduling kernel was first translated without abstraction from c++ into promela (the input language for spin). we constructed an abstract &ldquo;test-driver&rdquo; environment and carefully introduced several abstractions into the system to support verification. several experiments were run to attempt to verify that the system implementation adhered to the critical time partitioning requirements. during these experiments, the known error was rediscovered in the time partitioning implementation. we believe this case study provides several insights into how to develop cost-effective methods and tools to support the software design and implementation review process.
model-based testing. "broadcasting" is an information dissemination process in which a member of a system generates a message communicated to all other members. we model this process by ordered rooted trees and investigate a special class of rooted trees allowing broadcasting from the root to all other vertices of the tree in the minimum time (over all rooted trees with n vertices). we characterize trees from this class ("mbt") and give an algorithm deciding membership in the class. we also present an algorithm to construct all mbt's with a given number of vertices and give a recursive formula to count these trees.
holistic framework for establishing interoperability of heterogeneous software development tools and models. this research is an initial investigation into the development of a holistic framework for software engineering (hfse) that establishes mechanisms by which existing software development tools and models will interoperate. the hfse captures and uses dependency relationships among heterogeneous software development artifacts, the results of which can be used by software engineers to improve software processes and product integrity.
one evaluation of model-based testing and its automation. model-based testing relies on behavior models for the generation of model traces: input and expected output---test cases---for an implementation. we use the case study of an automotive network controller to assess different test suites in terms of error detection, model coverage, and implementation coverage. some of these suites were generated automatically with and without models, purely at random, and with dedicated functional test selection criteria. other suites were derived manually, with and without the model at hand. both automatically and manually derived model-based test suites detected significantly more requirements errors than hand-crafted test suites that were directly derived from the requirements. the number of detected programming errors did not depend on the use of models. automatically generated model-based test suites detected as many errors as hand-crafted model-based suites with the same number of tests. a sixfold increase in the number of model-based tests led to an 11% increase in detected errors.
software interconnection models. we present a formulation of interconnection models and present the unit and syntactic models &mdash; the primary models used for managing the evolution of large software systems. we discuss various tools that use these models and evaluate how well these models support the management of system evolution. we then introduce the semantic interconnection model. the semantic interconnection model incorporates the advantages of the unit and syntactic interconnection models and provides extremely useful extensions to them. by refining the grain of interconnections to level of semantics (that is, to the predicates that define aspects of behavior) we provide tools that are better suited to manage the details of evolution in software systems and that provide a better understanding of the implications of changes. we do this by using the semantic interconnection model to formalize the semantics of program construction, the semantics of changes, and the semantics of version equivalence and compatibility. thus, with this formalization, we provide tools that are knowledgeable about the process of system construction and evolution and that work in symbiosis with the system builders to construct and evolve large software systems.
version control in the inscape environment. we present the important issues to be considered in version control mechanisms and characterize and compare the kinds of version control systems extant in current programming environments. we then characterize inscape's version control mechanism. invariant, and show that it makes several significant advances in the state of the art. using instress (inscape's module interface specification language) specifications, invariant provides a better understanding of the notion of parallel versions, a more comprehensive notion of version consistency, and a more flexible method of system composition than current mechanisms. in particular, invariant provides a formalization of the notions of version equivalence and compatibility that correspond closely with our intuitive (and practical) notions of version equivalence and compatibility. these various forms of version compatibility provide the system builder with the concept of plug-compatibility &mdash; an extremely useful facility in composing systems from component parts.
a methodology for prototyping-in-the-large. the authors define prototyping as an experimental activity intended to reduce risk of failure in a software product. in this context, they explore the effect of scale in prototyping and then describe a methodology for prototyping a large application. the authors describe a system being developed to evaluate this methodology, featuring a pair of languages (promo and moblog) to serve both large-scale and component-level prototyping needs. the authors conclude with a presentation of how the proposed methodology would be applied to a sample problem, a fault-prediction subsystem within the space station freedom project
polyphony in architecture. based on interviews with a number of architects andmanagers from a wide range of organizations, we characterizehow architecture is perceived in practice. we identifythree groups of organizations that differ with respect to theirlevel of architectural thinking and the alignment of businessand it on architectural issues. analysis of the interviewsfurther indicates that these three groups differ in thearchitecture aspects and critical success factors they emphasize.our results provide a starting point for assessingarchitecture maturity and alignment within organizations,and can be used to help harmonize different architecturaltunes played within organizations.
the deployer's problem: configuring application servers for performance and reliability. frameworks such as j2ee are designed to simplify the process of developing enterprise applications by handling much of the complexity of concurrency, transaction, and persistence management. an application server that supports such a framework implements these concerns, freeing the application developer to focus on the task of implementing the business logic aspect of the application, in such frameworks, the deployer, the individual(s) who configures the application server to manage concurrency, transaction and persistence correctly and efficiently, plays a central role. a deployer has few tools to assist with performing this complicated task. incorrect configuration can lead to application failure or severe underperformance. we outline the problems facing the deployer of applications, present a methodology that can assist the programmer with the task of configuring application servers, and present two case studies that validate the usefulness of our methodology.
models of software development environments. we present a general model of software development environments that consists of three components: policies, mechanisms and structures. the advantage of this formalization is that it distinguishes precisely those aspects of an environment that are useful in comparing and contrasting software development environments. we introduce four classes of models by means of a sociological metaphor that emphasizes scale: the individual, the family, the city and the state models. the utility of this taxonomy is that it delineates the important classes of interaction among software developers and exposes the ways in which current software development environments inadequately support the development of large systems. environments reflecting the individual and family models are the current state of the art. unfortunately, these two models are ill-suited for the development of large systems that require more than, say, 20 programmers. we argue that there is a qualitative difference between the interactions among a small, &ldquo;family&rdquo; project and a large, &ldquo;city&rdquo; project and that this qualitative difference requires a fundamentally different model of software development environments. we illustrate the city model with inscape/infuse and istar, the only two environments we know of that instantiate this model, and show that there is a pressing need for further research on this kind of environment. finally, we postulate a state model, which is in need of further clarification, understanding and, ultimately, implementation.
one more step in the direction of modularized integration concerns. component integration creates value by automatingthe costly and error-prone task of imposing desiredbehavioral relationships on components manually.requirements for component integration, however,complicate software design and evolution in severalways: first, they lead to coupling among components;second, the code that implements various integrationconcerns in a system is often scattered over and tangledwith the code implementing the component behaviors.straightforward software design techniques mapintegration requirements to scattered and tangled code,compromising modularity in ways that dramaticallyincrease development and maintenance costs.
classpects: unifying aspect- and object-oriented language design. the contribution of this work is the design, implementation, and early evaluation of a programming language that unifies classes and aspects. we call our new module construct the classpect. we make three basic claims. first, we can realize a unified design without significantly compromising the expressiveness of current aspect languages. second, such a design improves the conceptual integrity of the programming model. third, it significantly improves the compositionality of aspect modules, expanding the program design space from the two-layered model of aspectj-like languages to include hierarchical structures. to support these claims, we present the design and implementation of eos-u, an aspectj-like language based on c# that supports classpects as the basic unit of modularity. we show that eos-u supports layered designs in which classpects separate integration concerns flexibly at multiple levels of composition. the underpinnings of our design include support for aspect instantiation under program control, instance-level advising, advising as a general alternative to object-oriented method invocation and overriding, and the provision of a separate join-point-method binding construct.
case studies for software engineers. the topic of this full-day tutorial was the correct useand interpretation of case studies as an empiricalresearch method. using an equal blend of lecture anddiscussion, it gave attendees a foundation for conducting,reviewing, and reading case studies. there were lessonsfor software engineers as researchers who conduct andreport case studies, reviewers who evaluate papers, andpractitioners who are attempting to apply results frompapers. the main resource for the course was the bookcase study research: design and methods by robert k.yin. this text was supplemented with positive andnegative examples from the literature.
case studies for software engineers. the topic of this full-day tutorial was the correct use and interpretation of case studies as an empirical research method. using an equal blend of lecture and discussion, it gave attendees a foundation for conducting, reviewing, and reading case studies. there were lessons for software engineers as researchers who conduct and report case studies, reviewers who evaluate papers, and practitioners who are attempting to apply results from papers. the main resource for the course was the book case study research: design and methods by robert k. yin. this text was supplemented with positive and negative examples from the literature.
parallel changes in large scale software development: an observational case study. an essential characteristic of large-scale software development is parallel development by teams of developers. how this parallel development is structured and supported has a profound effect on both the quality and timeliness of the product. we conduct an observational case study in which we collect and analyze the change and configuration management history of a legacy system to delineate the boundaries of, and to understand the nature of, the problems encountered in parallel development. the results of our studies are (1) that the degree of parallelism is very highhigher than considered by tool builders; (2) there are multiple levels of parallelism, and the data for some important aspects are uniform and consistent for all levels; (3) the tails of the distributions are long, indicating the tail, rather than the mean, must receive serious attention in providing solutions for these problems; and (4) there is a significant correlation between the degree of parallel work on a given component and the number of quality problems it has. thus, the results of this study are important both for tool builders and for process and project engineers.
symbolic interpretation and tracing of pascal-programs. in this paper we describe a system for symbolic interpretation and tracing of programs written in pascal. we show how the symbolic execution method of king can be extended to handle special pascal-features and complex data structures. the system is designed for practical use. it should support the programmer in the modular program development process without bothering him with additional specifications.
semantics-based reverse engineering of object-oriented data models. we present an algorithm for reverse engineering object-oriented (oo) data models from programs written in weakly-typed languages like cobol. these models, similar to uml class diagrams, can facilitate a variety of program maintenance and migration activities. our algorithm is based on a semantic analysis of the program's code, and we provide a bisimulation-based formalization of what it means for an oo data model to be correct for a program.
test case generation using prolog. for the validation of the kernel system calls of a family of unix 1) systems a knowledge based test environment was conceived. a prototype version is currently implemented in prolog. the knowledge base consists essentially of three parts: test case specifications of the various system calls, a test suite generator with predicates including information about unix system properties and sound test practices, and a test protocol archive including utilities to extract and prepare reports about the test results. all information in the knowledge base is stored as horn clauses, i.e. facts and rules immediately to be consulted and executed by a prolog interpreter.
a model of software engineering. the field of software engineering is currently in its formative stages. consequently, it does not exhibit the structure and discipline present in other, more established engineering disciplines. the technique of morphological analysis is applied to the field of software engineering to identify the form and structure present. applications in the areas of software engineering research and software engineering curricula are discussed.
dual: an interactive tool for developing documented programs by step-wise refinements. programs are integrated hierarchical structures of formal texts - instructions - and informal texts - documentation. only if there is a mechanical connection between program design and program development there can be higher chances that the program documentation, originated at design time, will not, sooner or later, become obsolete with respect to the current state of the system. dual is an interactive, incremental, intelligent editor of program and documentation texts to be used for software implementations whose anticipated life cycle is significantly long to deserve much attention. the screen interface plays a unique role in dual since it allows a visitor ( designer or maintenance engineer) &ldquo;to replay&rdquo; as many times as desired the evolution of the system from design to implementation. the access to the hierarchically organized design information is made easy and natural by the dual video oriented user interface.