Systems that are assembled from independently developed features suffer from feature interactions, in which features affect one another's behaviour in surprising ways. To ensure that a system behaves as intended, developers need to analyze all potential interactions -- and many of the identified interactions need to be fixed and their fixes verified. The feature-interaction problem states that the number of potential interactions to be considered is exponential in the number of features in a system. Resolution strategies combat the feature-interaction problem by offering general strategies that resolve entire classes of interactions, thereby reducing the work of the developer who is charged with the task of resolving interactions. In this thesis, we focus on resolving interactions due to conflict. We present an approach, language, and implementation based on resolver modules modelled in the situation calculus in which the developer can specify an appropriate resolution for each variable under conflict. We performed a case study involving 24 automotive features, and found that the number of resolutions to be specified was much smaller than the number of possible feature interactions (6 resolutions for 24 features), that what constitutes an appropriate resolution strategy is different for different variables, and that the subset of situation calculus we used was sufficient to construct nontrivial resolution strategies for six distinct output variables.

In the last few years the rapidly expanding application of computer technology has brought the problems of software production increasingly to the fore, and it is widely accepted that current software development techniques are unable to produce high quality software at the rate required to keep pace with this. To try to improve this imbalance, the fte1d of Software Engineering has been advanced as a possible solution, attempting to apply the formal methods of an engineering discipline to software design and implementation. One of the most promising areas to be developed in this fte1d is that of Integrated Project Support Environments (IPSE's), which attempt to spread the focus of attention during software development from the coding stage to embrace the whole development cycle, from initial requirements speciftcation through to operational maintenance. These environments hope to improve prodUction efficiency and quality by providing a complete set of support tools to help with each stage of software development, and to supply the necessary tool integration to ensure a smooth transition of use between these tools. This thesis examines the services provided as part of an IPSE which allow users and tools to interact in a meaningful way throughout the life of a project. In particular, a view mechanism is seen as a vital component of these services allowing indiVidual external views of the facilities to be deftned which suit different users' needs. A model of a view mechanism for an IPSE is developed, and within a particular implementation of an IPSE, a view mechanism is formally deftned and implemented. Finally, the view mechanism is analysed and discussed before concluding with some directions for future research.

Software product lines (SPLs) manage product variants in a systematical way and allow stakeholders to derive variants by selecting features. Finding a desirable variant is hard, due to the huge configuration space and usually conflicting objectives (e.g., lower cost and higher performance). This scenario can be reduced to a multi-objective optimization prob- lem in SPLs. We address the problem using an exact and an approximate algorithm and compare their accuracy, time consumption, scalability and parameter setting requirements on five case studies with increasing complexity. Our empirical results show that (1) it is feasible to use exact techniques for small SPL multi-objective optimization problems, and (2) approximate methods can be used for large problems but require substantial effort to find the best parameter settings for acceptable approximation. Finally, we discuss the tradeoff between accuracy and time consumption when using exact and approximate techniques for SPL multi-objective optimization and guide stakeholders to choose one or the other in practice.

The cloning of code is controversial as a development practice. Empirical studies on the long-term effects of cloning on software quality and maintainability have produced mixed results. Some studies have found that cloning has a negative impact on code readability, bug propagation, and the presence of cloning may indicate wider problems in software design and management. At the same time, other studies have found that cloned code is less likely to have defects, and thus is arguably more stable, better designed, and better maintained. These results suggest that the effect of cloning on software quality and maintainability may be determinable only on a case-by-case basis, and this only aggravates the challenge of establishing a principled framework of clone management and understanding. This thesis aims to improve the understanding and management of clones within software systems. There are two main contributions. First, we have conducted an empirical study on cloning in one of the major device drivers families of the Linux kernel. Different from many previous empirical studies on cloning, we incorporate the knowledge about the development style, and the architecture of the subject system into our study; our findings address the evolution of clones; we have also found that the presence of cloning is a strong predictor (87\% accuracy) of one aspect of underlying hardware similarity when compared to a vendor-based model (55\% accuracy) and a randomly chosen model (9\% accuracy). The effectiveness of using the presence of cloning to infer high-level similarity suggests a new perspective of using cloning information to assist program comprehension, aspect mining, and software product-line engineering. Second, we have devised a triage-oriented taxonomy of clones to aid developers in prioritizing which kinds of clones are most likely to be problematic and require attention; a preliminary validation of the utility of this taxonomy has been performed against a large open source system. The cloning-based software quality assurance (QA) framework based on our taxonomy adds a new dimension to traditional software QA processes; by exploiting the clone detection results within a guided framework, the developer is able to evaluate which instances of cloning are most likely to require urgent attention.

A software developer explores a software system by asking and answering a series of questions. To answer these questions, a developer may need to consult various sources providing information about the program, such as the static relationships expressed directly in the source code, the run-time behaviour of a program recorded in a dynamic trace, or evolution history as recorded in a source management system. Despite the support afforded by software exploration tools, developers often struggle to find the necessary information to answer their questions and may even become disoriented, where they feel mentally lost and are uncertain of what they were trying to accomplish. This dissertation advances a thesis that a developer's questions, which we refer to as conceptual queries, can be better supported through a model to represent and compose different sources of information about a program. The basis of this model is the sphere, which serves as a simple abstraction of a source of information about a program. Many of the software exploration tools used by a developer can be represented as a sphere. Spheres can be composed in a principled fashion such that information from a sphere may replace or supplement information from a different sphere. Using our sphere model, for example, a developer can use dynamic runtime information from an execution trace to replace information from the static source code to see what actually occurred. We have implemented this model in a configurable tool, called Ferret. We have used the facilities provided by the model to implement 36 conceptual queries identified from the literature, blogs, and our own experience, and to support the integration of four different sources of program information. Establishing correspondences between similar elements from different spheres allows a query to bridge across different spheres in addition to allowing a tool's user interface to drive queries from other sources of information. Through this effort we show that sphere model broadens the set of possible conceptual queries answerable by software exploration tools. Through a small diary study and a controlled experiment, both involving professional software developers, we found the developers used the conceptual queries that were available to them and reported finding Ferret useful.

This thesis is devoted to a component model for Web application and the corresponding tools for its development. The model is described after the review of various existing Web application development methods and models. A case study is also provided to support the analysis. -- abstract / Thesis (PhD)--University of South Australia, 2003.

???Agent-based systems are one of the most vibrant and important areas of research and development to have emerged in information technology in the 1990s??? (Luck et al. 2003). The use of agents as a metaphor for designing and constructing software systems represents an innovative movement in the field of software engineering: ???Agent- Oriented Software Engineering (AOSE)??? (Lind 2000; Luck et al. 2003). This research contributes to the evolution of AOSE by proposing a comprehensive ontology-based methodology for the analysis and design of Multi-Agent Systems (MAS). The methodology is named MOBMAS, which stands for ???Methodology for Ontology-Based MASs???. A major improvement of MOBMAS over the existing agentoriented MAS development methodologies is its explicit and extensive support for ontology-based MAS development. Ontologies have been widely acknowledged for their significant benefits to interoperability, reusability, MAS development activities (such as system analysis and agent knowledge modelling) and MAS operation (such as agent communication and reasoning). Recognising these desirable ontology???s benefits, MOBMAS endeavours to identify and implement the various ways in which ontologies can be used in the MAS development process and integrated into the MAS model definitions. In so doing, MOBMAS has exploited ontologies to enhance its MAS development process and MAS development product with various strengths. These strengths include those ontology???s benefits listed above, and those additional benefits uncovered by MOBMAS, e.g. support for verification and validation, extendibility, maintainability and reliability. Compared to the numerous existing agent-oriented methodologies, MOBMAS is the first that explicitly and extensively investigates the diverse potential advantages of ontologies in MAS development, and which is able to implement these potential advantages via an ontology-based MAS development process and a set of ontology-based MAS model definitions. Another major contribution of MOBMAS to the field of AOSE is its ability to address all key concerns of MAS development in one methodological framework. The methodology provides support for a comprehensive list of methodological requirements, which are important to agent-oriented analysis and design, but which may not be wellsupported by the current methodologies. These methodological requirements were identified and validated by this research from three sources: the existing agent-oriented methodologies, the existing evaluation frameworks for agent-oriented methodologies and conventional system development methodologies, and a survey of practitioners and researchers in the field of AOSE. MOBMAS supports the identified methodological requirements by combining the strengths of the existing agent-oriented methodologies (i.e. by reusing and enhancing the various strong techniques and model definitions of the existing methodologies where appropriate), and by proposing new techniques and model definitions where necessary. The process of developing MOBMAS consisted of three sequential research activities. The first activity identified and validated a list of methodological requirements for an Agent Oriented Software Engineering methodology as mentioned above. The second research activity developed MOBMAS by specifying a development process, a set of techniques and a set of model definitions for supporting the identified methodological requirements. The final research activity evaluated and refined MOBMAS by collecting expert reviews on the methodology, using the methodology on an application and conducting a feature analysis of the methodology.

This thesis investigates the process of designing software from formal specifications, in particular, specifications expressed in the Z notation. The initial phases of software design have significant impact on software quality and the transition from formal specification to design is not clearly understood. There is often no visible or obvious connection between the specification and the finished design. It is possible to add traceability with either verification or refinement, but I wish to understand and guide the design process. Investigating the design of software from formal specifications highlighted possible relationships between parts of the specification and parts of the design. A design strategy is introduced, that combines software architectural styles and formal specifications to influence the generated design. The design process is architecturally-specific, but a template for instantiating the design process to a chosen architectural style is presented. Specializations of the template are presented for the ADT-based architectural style and the event-based architectural style. These specializations of the template produce an architecturally-constrained, specification-influenced design process. Providing an architecturally-constrained, specification-influenced design process enables the software designer to produce better quality software. The constrained design process allows the designer to focus on the difficult aspects of design: understanding the problem, choosing the best abstractions, and finding a suitable solution.

Thesis (M.S.)--Oregon State University, 2008. / Printout. Includes bibliographical references (leaves 82-84). Also available on the World Wide Web.

Thesis (M.S.)--West Virginia University, 2008. / Title from document title page. Document formatted into pages; contains vii, 83 p. : ill. (some col.). Vita. Includes abstract. Includes bibliographical references (p. 81-83).