waashk/dblp huggingface dataset:
generalizing perspective-based inspection to handle object-oriented development artifacts. the value of software inspection for uncovering defects early in the development lifecycle has been well documented. of the various types of inspection methods published to date, experiments have shown perspective-based inspection to be one of the most effective, because of its enhanced coverage of the defect space. however, inspections in general, and perspective-based inspections in particular, have so far been applied predominantly in the context of conventional structured development methods, and then almost always to textual artifacts, such as requirements documents or code modules. object-oriented models, particularly of the graphical form, have so far not been adequately addressed by inspection methods. this paper tackles this problem by first discussing the difficulties involved in tailoring the perspective-based inspection approach to object-oriented development methods and, second, by presenting a generalization of the approach which overcomes these limitations. the new version of the approach is illustrated in the context of uml-based object-oriented development.
rule-based approach to computing module cohesion. stevens, myers, and constantine introduced the notion of cohesion, an ordinal scale of seven levels that describes the degree to which the actions performed by a module contribute to a unified function (1974). they provided rules, termed as associative principles to examine the relationships between processing elements of a module and designate a cohesion level to it. stevens et al., however, did not give a precise definition for the term processing element. the author interprets the output variables of a module as its processing elements. stevens et al.'s associative principles are transformed to relate the output variables based on their data and control dependence relationships. what results is a rule-based approach to computing cohesion. experimental results show that, but for temporal cohesion, the cohesion associated to a module under this reinterpretation and that due to the original definitions are identical for all examples
requirements engineering in the year 00: a research perspective. requirements engineering (re) is concerned with the identification of the goals to be achieved by the envisioned system, the operationalization of such goals into services and constraints, and the assignment of responsibilities for the resulting requirements to agents such as humans, devices, and software. the processes involved in re include domain analysis, elicitation, specification, assessment, negotiation, documentation, and evolution. getting high-quality requirements is difficult and critical. recent surveys have confirmed the growing recognition of re as an area of utmost importance in software engineering research and practice.the paper presents a brief history of the main concepts and techniques developed to date to support the re task, with a special focus on modeling as a common denominator to all re processes. the initial description of a complex safety-critical system is used to illustrate a number of current research trends in re-specific areas such as goal-oriented requirements elaboration, conflict management, and the handling of abnormal agent behaviors. opportunities for goal-based architecture derivation are also discussed together with research directions to let the field move towards more disciplined habits.
goal-oriented requirements engineering: from system objectives to uml models to precise software specifications. this tutorial presents a comprehensive overview of state-of-the-art techniques for eliciting, modeling, specifying, analyzing and documenting high-quality system requirements.
elaborating security requirements by construction of intentional anti-models. caring for security at requirements engineering time is amessage that has finally received some attention recently.however, it is not yet very clear how to achieve thissystematically through the various stages of therequirements engineering process.the paper presents a constructive approach to themodeling, specification and analysis of application-specificsecurity requirements. the method is based on agoal-oriented framework for generating and resolvingobstacles to goal satisfaction. the extended frameworkaddresses malicious obstacles (called anti-goals) set up byattackers to threaten security goals. threat trees are builtsystematically through anti-goal refinement until leafnodes are derived that are either software vulnerabilitiesobservable by the attacker or anti-requirementsimplementable by this attacker. new security requirementsare then obtained as countermeasures by application ofthreat resolution operators to the specification of the anti-requirementsand vulnerabilities revealed by the analysis.the paper also introduces formal epistemic specificationconstructs and patterns that may be used to support aformal derivation and analysis process. the method isillustrated on a web-based banking system for whichsubtle attacks have been reported recently.
improving the quality of uml models in practice. the importance of uml models in software engineering is increasing. inherent to the uml is its lack of a formal semantics, its risk for inconsistency and completeness defects and the absence of modeling norms. these properties are sources for poor model quality and defects. to find out to which extent defects occur and what types of defects occur in practice we empirically investigate the state-of-the-practice of quality in uml models using a practitioners survey and a series of industrial case studies. additionally we analyze the effects of defects in uml models experimentally. based on this experiment we present an objective classification of uml defects which allows for prioritizing defects and thus allocate resources for defect removal. we aim at building a rule-set, metrics and visualization techniques to improve the quality of uml models during development. we propose a quality model that is specific for uml models. finally, we propose modeling conventions, similar to coding conventions, to prevent for defects and to assure uniformity of modeling within an organization. we aim at empirically validating our techniques to provide pragmatic technology that can be transferred to industrial practice.
effects of defects in uml models: an experimental investigation. the unified modeling language (uml) is the de facto standard for designing and architecting software systems. uml offers a large number of diagram types that can be used with varying degree of rigour. as a result uml models may contain consistency defects. previous research has shown that industrial uml models that are used as basis for implementation and maintenance contain large numbers of defects. this study investigates to what extent implementers detect defects and to what extent defects cause different interpretations by different readers. we performed two controlled experiments with a large group of students (111) and a group of industrial practitioners (48). the experiment's results show that defects often remain undetected and cause misinterpretations. we present a classification of defect types based on a ranking of detection rate and risk for misinterpretation. additionally we observed effects of using domain knowledge to compensate defects. the results are generalizable to industrial uml users and can be used for improving quality assurance techniques for uml-based development.
codecrawler: an information visualization tool for program comprehension. codecrawler (in the remainder of the text cc) is a language independent, interactive, information visualization tool. it is mainly targeted at visualizing object-oriented software, and has been successfully validated in several industrial case studies over the past few years. cc adheres to lightweight principles: it implements and visualizes polymetric views, visualizations of software enriched with information such as software metrics and other source code semantics. cc is built on top of moose, an extensible language independent reengineering environment that implements the famix metamodel. in its last implementation, cc has become a general-purpose information visualization tool.
tutorial: mastering design patterns. this tutorial is an introduction to design patterns used in the design of object-oriented software applications.
slicing object-oriented software. describes the construction of system dependence graphs for object-oriented software on which efficient slicing algorithms can be applied. we construct these system dependence graphs for individual classes, groups of interacting classes and complete object-oriented programs. for an incomplete system consisting of a single class or a number of interacting classes, we construct a procedure dependence graph that simulates all possible calls to public methods in the class. for a complete system, we construct a procedure dependence graph from the main program in the system. using these system dependence graphs, we show how to compute slices for individual classes, groups of interacting classes and complete programs. one advantage of our approach is that the system dependence graphs can be constructed incrementally because representations of classes can be reused. another advantage of our approach is that slices can be computed for incomplete object-oriented programs such as classes or class libraries. we present our results for c++, but our techniques can be applied to other statically typed object-oriented languages such as ada-95.
module structure in an evolving family of real time systems. the problems of maintaining a large number of customized software systems are discussed. module structuring techniques developed at bell-northern research and used in the development of the northern telecom dms 100 family of telephone switching equipment are described. application of these techniques simplifies the evolution of the system to handle new features.
dynamic mutation testing in integrated regression analysis. a new method of integrated regression analysis is proposed. its core is the clustering, a method for automatic identification of program modifications. clustering is used to formulate a hypothesis about the existence of a fault in the modified program, and to guide the process of testing this hypothesis. it is postulated that static and dynamic program analysis be used for that purpose. specifically, the authors introduce dynamic mutation testing (dmt), an experimental technique for testing the fault hypothesis. dmt estimates the sensitivity of the test-induced program state to reveal the postulated fault in the modified program. if all tests pass and are found to have a high sensitivity, the fault hypothesis can be rejected at a high level of confidence
the impact of mesa on system design. the mesa programming language supports program modularity in ways that permit subsystems to be developed separately but to be bound together with complete type safety. separate and explicit interface definitions provide an effective means of communication, both between programs and between programmers. a configuration language describes the organization of a system and controls the scopes of interfaces. these facilities have had a profound impact on the way we design systems and organize development projects. this paper reports our recent experience with mesa, particularly its use in the development of an operating system. it illustrates techniques for designing interfaces, for using the interface language as a specification language, and for organizing a system to achieve the practical benefits of program modularity without sacrificing strict type-checking.
automated support for process-aware definition and execution of measurement plans. some of the problems with process measurement are generally due to the fact that the definition of measurement plans does not rely on a reference model of the development process that can drive and explain the measuring activities. one of the most popular methodologies addressing the definition of process measurement plans is the gqm (goal/question/metrics). this paper discusses how to support the creation of gqm plans by means of an explicit model of the process being measured. such a model guides the gqm process, and makes it possible to define precisely -if not formally- the metrics involved. a tool supporting the proposed method is also illustrated.
a constructive approach to reliable synchronization code. this paper describes a new approach to developing reliable software for communication between parallel processes. the basis of this approach is the shared use of abstract data objects, and the separation of synchronization-related software from the software performing the actual data access. the paper presents a language in which synchronization behavior for abstract data objects can be specified independently of other kinds of behavior. specifications written in this language can be used as a basis for constructing the required synchronization software automatically. also discussed is the use of such specifications in verifying properties of programs which make use of the abstract objects for interprocess communication.
whole program path-based dynamic impact analysis. impact analysis, determining when a change in one part of a program affects other parts of the program, is time-consuming and problematic. impact analysis is rarely used to predict the effects of a change, leaving maintainers to deal with consequences rather than working to a plan. previous approaches to impact analysis involving analysis of call graphs, and static and dynamic slicing, exhibit several tradeoffs involving computational expense, precision, and safety, require access to source code, and require a relatively large amount of effort to re-apply as software evolves. this paper presents a new technique for impact analysis based on whole path profiling, that provides a different set of cost-benefits tradeoffs -- a set which can potentially be beneficial for an important class of predictive impact analysis tasks. the paper presents the results of experiments that show that the technique can predict impact sets that are more accurate than those computed by call graph analysis, and more precise (relative to the behavior expressed in a program's profile) than those computed by static slicing.
an examination of evolution dynamics. data on the history of seven systems was analysed to statistically test the 5 laws of software evolution proposed first by belady and lehman in 1976. while there was some evidence supporting laws 1 and 2, laws 3-5 were not supported by the data. in the light of the result a new discontinuous model of software evolution is proposed to replace the smoothly changing continuous model proposed by lehman.
using kids as a tool support for vdm. kids/vdm is an experimental environment that supports the synthesis of executable prototypes from vdm specifications. the development proceeds as a series of correctness preserving transformations under the strict control of the tool. a by-product of this development is the proof of consistency properties of the original specification. experiments with the tool have shown its ability to handle independently written specifications. it also revealed useful to detect errors in specifications. the environment is based on, technologies of the kestrel institute development system, including the refine and regroup languages, the design and optimization tactics, and the theorem prover.
application of clustering to estimate missing data and improve data integrity. two problems in the use of computerized data base systems are: (1) how can we estimate the values for missing data? (2) how can we improve data integrity, that is, reduce the number of errors in the data? the tool that we introduce to attack these problems is clustering analysis. experimental results indicate that our method is feasible. our algorithm detected an error in the book &ldquo;weyer's warships of the world 1969.&rdquo; each of the approximately 2000 warships listed in the book has 18 variables associated with it. it would be difficult for a person to find errors in the book. our methods do not require any a priori knowledge about the data, for example, about warships.
software architectures for dependable systems: a software engineering perspective. although there is a large body of research in dependability, architectural level reasoning about dependability is only just emerging as an important theme in software development. this is due to the fact that dependability concerns are often left until too late in the process of development. in addition, the complexity of emerging applications and the trend of building trustworthy systems from existing untrustworthy components are urging dependability concerns to be considered at the architectural level. this tutorial will present the current challenges and promising solutions for structuring dependable systems at the architectural level. in addition of providing basic concepts related to dependability and software architectures, the rest of the tutorial is presented in the context of the dependability technologies. throughout the tutorial, case studies will be used to exemplify the key concepts.
icse 2002 workshop on architecting dependable systems. this summary gives a brief overview of a one-day workshop on architecting dependable systems (wads) held in conjunction with icse 2004. it was organised as a twin workshop with a workshop held in conjunction with the international conference on dependable systems and network (dsn 2004).
program evolution and its impact on software engineering. large scale, widely used programs such as operating systems are never complete. they undergo a continuing evolutionary cycle of maintenance, augmentation and restructuring to keep pace with evolving usage and implementation technologies. the paper provides quantitative evidence, from widely different environments, of the existence and nature of this evolutionary process. interpretations and possible significance of some of the observed phenomena are discussed. some implications for software engineering and for project planners and managers are noted.
icse 2003 workshop on software architectures for dependable systems. this workshop summary gives a brief overview of a one-day workshop on "software architectures for dependable systems" held in conjunction with icse 2003.
twin workshops on architecting dependable systems (wads 2004). this workshop summary gives a brief overview onthe workshop on "architecting dependable systems"held in conjunction with icse 2004. it is organisedas a twin workshop to another to be held inconjunction with the international conference ondependable systems and network (dsn 2004). thisis an ambitious project that aims to promote cross-fertilizationbetween the communities of softwarearchitectures and dependability. both communitieswill benefit from the clarification of approaches thathave been previously tried and succeeded, as well asthose that have been tried but have not yet shown tobe successful.
workshop on architecting dependable systems (wads 2005). this workshop summary gives a brief overview of the workshop on "architecting dependable systems" held in conjunction with the icse 2005. the main aim of this workshop is to promote cross-fertilization between the software architecture and dependability communities. we believe that both of them will benefit from clarifying approaches that have been previously tested and have succeeded as well as those that have been tried but have not yet been shown to be successful.
tutorial on fundamental concepts for practical software architecture. architecture of software is a collection of design decisions that are expensive to change. how to identify which design decisions are expensive to change? what are architecture views and which views are needed to adequately describe the architecture of a specific system? how to create and manage software architecture for a product family? this tutorial offers answers to these and other questions that arise in the context of complex software development. we introduce a system of concepts useful in order to understand, design, and evaluate architecture of software intensive systems and system families. our approach utilizes different software structures in order to control important system qualities related to its development, performance, and evolution. we draw our experience primarily from software embedded in voice and data communication systems. however the same principles can be applied to software architecture in other domains. this tutorial should be useful to engineers and technical managers involved in construction or evaluation of complex software.
the icse2000 doctoral workshop. doctoral research in software engineering is a major source of new ideas and of key importance in training scientists for the information technology community. the rapid evolution of information technology is challenging the relevance of doctoral programs in software engineering. these are facing the risk of losing their leading role in training scientists and engineers. many universities are threaten by a decreasing number of applications and an increasing number of drop outs. a major goal of the icse doctoral workshop, at the turn of the millennium, is to promote doctoral study and provide help and encouragement to those engaged in it. consequently, the icse2000 doctoral workshop not only provides a forum for graduate students to present and discuss their dissertation research, it also provides (together with a panel session in the main conference) an opportunity to discuss the role of doctoral research in the new information society. an opening talk by lee osterweil is intended to give participants a clear view of both the goal of doctoral research and the methodology with which it is carried out. the presentation of doctoral plans and the open discussion between the committee and the invited students is a unique opportunity to compare phd programs in different institutions and in different countries. the summary panel scheduled as part of the conference program is designed to open the discussion between the academic and the industrial communities on the role that doctoral research plays in the development and evolution of software engineering.
an empirical evaluation of test case filtering techniques based on exercising complex information flows. some software defects trigger failures only when certain complex information flows occur within the software. profiling and analyzing such flows therefore provides a potentially important basis for filtering test cases. we report the results of an empirical evaluation of several test case filtering techniques that are based on exercising complex information flows. both coverage-based and profile-distribution-based filtering techniques are considered. they are compared to filtering techniques based on exercising basic blocks, branches, function calls, and def-use pairs, with respect to their effectiveness for revealing defects.
graphical animation of behavior models. graphical animation is a way of visualizing the behavior of design models. this visualization is of use in validating a design model against informally specified requirements and in interpreting the meaning and significance of analysis results in relation to the problem domain. in this paper we describe how behavior models specified by labeled transition systems (lts) can drive graphical animations. the semantic framework for the approach is based on timed automata. animations are described by an xml document that is used to generate a set of javabeans. the elaborated javabeans perform the animation actions as directed by the lts model.