Although existing automated merging tools have made efforts in merging displayed text and syntactic conflicts, the deep logical and semantic conflicts that do not cause compilation errors still require human review to fully resolve. In order to make the merged results more reliable and reduce the workload of human review, we propose DEEPGRAPHMERGE, a reliable merge conflict resolution system that specifically detects and resolves deep logical and semantic conflicts in collaborative development. Our method combines hierarchical directed graph neural networks (HD-GNN) with static analysis to identify and reconcile complex, deep semantic and logical conflicts across files. The key innovation lies in our hierarchical dependency graph, which explicitly explores the underlying program logic, enabling precise detection of deep semantic and logical conflicts. Experimental results across four languages (Java, C#, JavaScript, TypeScript) demonstrate superior performance: 91.2% accuracy in resolving challenging semantic and logical conflicts. The method’s ability to understand and harmonize deep semantic and logical differences represents a significant advance over current merge technologies.

Framework-based multilingual software development (MLSD) is becoming prevalent in software engineering practice. Despite the advantages, framework-based MLSD also leads to reduced understandability and changeability of multilingual software, due to the introduced cross-language links (XLLs). To help alleviate this problem, there are existing practice and research crafting rules to specify and detect XLLs, but only focusing on specific frameworks. With the intention of coping with the diversity of XLL conventions across different multi-lingual frameworks, this paper proposes Focused, an extensible approach to framework-oriented cross-language link specification and detection. The basic idea is to decouple the two activities of XLL specification and detection as much as possible by mediating between them with a set of DSL-enabled XLL rules, making Focused configurable to different multilingual frameworks. We evaluated Focused on 3 widely-used multilingual frameworks and 15 high-starred open-source projects using these frameworks, showing the expressiveness, effectiveness, and efficiency of Focused.

In collaborative software development, developers generally make code changes and commit the changes to the repositories. Among others, "making small, single-purpose commits" is considered the best practice for making commits, allowing the team to quickly understand the code changes. Rather than following best practices, developers often make tangled commits, which wrap code changes that implement different purposes. Such commits make it difficult for other developers to understand the code changes when conducting subsequent development. Early works on untangling code changes rely on human-specified heuristic rules or features, do not consider context, and are labor intensive. Recent works model the local context of code changes as a graph at the statement level, with statements as nodes and code dependencies as edges, and then cluster the changed statements. However, recent works ignore the hidden dependencies in the global context, e.g. a pair of tangled code changes may have no code dependency, and a pair of untangled code changes may have obvious code dependency. To solve this problem, we focus on detecting hidden dependencies among code changes. We model the global context of code changes as graphs at finer-grained, hierarchical levels, i.e., at both entity and statement levels. Then we propose a Heterogeneous Directed Graph Neural Network (HD-GNN) to detect hidden dependencies among code changes by aggregating the global context in both connected or disconnected entity-level subgraphs that intersected with the code changes. Evaluation of common C # and Java datasets with 1,612 and 14k tangled commits and manually validated datasets (MVD) with 600 commits shows that HD-GNN achieves an average enhancement of effectiveness of 25% and 19.2% compared to existing approaches and far superior to existing approaches in MVD, without sacrificing time efficiency.

The performance of repository-level code completion depends upon the effective leverage of both general and repository-specific knowledge. Despite the impressive capability of code LLMs in general code completion tasks, they often exhibit less satisfactory performance on repository-level completion due to the lack of repository-specific knowledge in these LLMs. To address this problem, we propose GraphCoder, a retrieval-augmented code completion framework that leverages LLMs' general code knowledge and the repository-specific knowledge via a graph-based retrieval-generation process. In particular, GraphCoder captures the context of completion target more accurately through code context graph (CCG) that consists of control-flow, data- and control-dependence between code statements, a more structured way to capture the completion target context than the sequence-based context used in existing retrieval-augmented approaches; based on CCG, GraphCoder further employs a coarse-to-fine retrieval process to locate context-similar code snippets with the completion target from the current repository. Experimental results demonstrate both the effectiveness and efficiency of GraphCoder: Compared to baseline retrieval-augmented methods, GraphCoder achieves higher exact match (EM) on average, with increases of +6.06 in code match and +6.23 in identifier match, while using less time and space.

Heterogeneous graphs provide a universal data structure for representing various kinds of structured data in numerous domains. The graph alignment problem aims to find the correspondences of vertices in different graphs, playing a fundamental role in many downstream tasks of heterogeneous graph mining. In recent years, many graph alignment methods have been proposed, ranging from classical optimization methods , spectral methods , to embedding learning based-methods . Due to the problem's complexity, the result found by most existing methods is either a heuristic solution or a critical point in the solution space. In this paper, we propose GABoost, a graph alignment boosting algorithm that takes as input an initial alignment between two heterogeneous graphs and outputs a boosted alignment via an iterative local-optimum-escape process. One of the distinctive features of GABoost is that it can be sequentially composed with any graph alignment methods to improve the output of upstream methods. To examine the effectiveness of GABoost, we select 7 upstream methods of graph alignment as well as 6 real-world datasets, and quantitatively investigate the degree to which GABoost boosts these methods. The results show that GABoost improves the alignment accuracy of the 7 upstream methods by 25.25% on average with acceptable time overhead.

Shape formation mechanism plays an essential role in many natural processes, involving the formation and evolution of living or non-living structures, and shows potential applications in many emerging domains. In existing research and practice, there still lacks a shape formation mechanism that manifestsefficiency,scalability, andstabilityat the same time. Inspired byphototaxisobserved in nature, we propose a self-organized approach for the massive formation of connected shapes in grid environments. The key component of this approach is anartificial light fieldsuperimposed on a grid environment, which is determined by the positions of all agents and at the same time drives all agents to change their positions, forming a dynamic mutual feedback process. To evaluate the effectiveness of this approach, we conduct a set of simulations, involving 156 shapes from 16 categories, comparing with four baseline methods. The results show that: (1) our approach outperforms the three semi-/decentralized non-optimal baselines inefficiency,scalability, andstability; (2) compared to the centralized optimal baseline, our approach exhibits considerable decreases in theabsolute completion timeon diverse shape formation tasks, indicating a better efficiency and scalability of our approach.Note to Practitioners—In nature, shape formation phenomena emerge from collective behaviors of swarms based on chemical or physical signals. These natural phenomena provide valuable insights to build large-scale multi-agent collaboration systems using software-defined digital signals. This work proposes a phototaxis-inspired computational approach for shape formation that enables a massive swarm of agents to form arbitrary connected shapes in grid environments based on a digital signal called artificial light field. The significance of this work is twofold: 1. it could contribute to a deep understanding of shape formation mechanisms; 2. it would motivate new research on advanced multi-agent algorithms, massive collaboration mechanisms, and artificial collective intelligence systems and facilitate their practical applications. Specifically, the shape formation mechanism has promising applications, including smart warehouses, autonomous cooperation of UAVs, and intelligent transportation systems. A possible realistic application scenario of our method in intelligent transportation systems is bike sharing systems, in which the designated parking areas for shared bicycles near the work area are often overcrowded and difficult to park in during the morning peak period, so dynamic parking route guidance for users is required. Our method can directly apply to this scenario by utilizing the light field to represent the parking state of nearby bicycles and guiding the moving direction of each user.

Framework-based multi-lingual software is increasingly prevalent, but it also brings negative effects and extra burden on software maintenance and evolution, because of the introduced cross-language code coupling, which are usually mixed with framework-specific conventions. Researchers have proposed various approaches to code coupling detection, but there is still a lack of necessary support for cross-language coupling detection in framework-based software development. In this paper, we present a preliminary study about cross-language coupling detection in software development based on the Android application framework. We investigate the characteristics of multi-lingual changes in the top-100 starred open-source Android repositories on GitHub, and find that multi-lingual commits are non-trivial: their code changes are more scattered, and more inclined to introduce bugs than other commits. To mitigate the side-effect of multi-lingual development, we propose Grace, a Graph-based cross-language co-change suggestion approach for Android application development. Grace (a) designs a language-agnostic graph to represent code elements from different languages, and (b) employs an entity-based collaborative filtering algorithm to detect and rank candidates of cross-language code couplings, from the graph representation of the latest version as well as the historical multi-lingual commits of a repository. To evaluate the effectiveness of Grace, we apply it to the two tasks of cross-language co-change suggestion and inconsistency checking. Results show that Grace (a) can effectively suggest cross-language co-changed files and types, and (b) can also find existing and potential bugs or code smells caused by inconsistent co-changes.

Code merging plays an important role in collaborative software development. However, it is often tedious and error-prone for developers to manually resolve merge conflicts, especially when there are many conflicts after merging long-lived branches or parallel versions. In this paper, we present SoManyConflicts, a language-agnostic approach to help developers resolve merge conflicts systematically, by utilizing their interrelations (e.g., dependency, similarity, etc.). SoManyConflicts employs a graph representation to model these interrelations and provides 3 major features: 1) cluster and order related conflict based on the graph connectivity; 2) suggest related conflicts of one focused conflict based on the topological sorting, 3) suggest resolution strategies for unresolved conflicts based already resolved ones. We have implemented SoManyConflicts as a Visual Studio Code extension that supports multiple languages (Java, JavaScript, and TypeScript, etc.), which is briefly introduced in the video: https://youtu.be/asWhj1KTU. The source code is publicly available at: https://github.com/Symbolk/somanyconflicts.

In collaborative software development, it is considered to be a best practice to submit code changes as a sequence of cohesive commits, each of which records the work result of a specific development activity, such as adding a new feature, bug fixing, and refactoring. However, rather than following this best practice, developers often submit a set of loosely-related changes serving for different development activities as a composite commit, due to the tedious manual work and lack of effective tool support to decompose such a tangled changeset. Composite commits often obfuscate the change history of software artifacts and bring challenges to efficient collaboration among developers. To encourage activity-oriented commits, we propose SmartCommit, a graph-partitioning-based interactive approach to tangled changeset decomposition that leverages not only the efficiency of algorithms but also the knowledge of developers. To evaluate the effectiveness of our approach, we (1) deployed SmartCommit in an international IT company, and analyzed usage data collected from a field study with 83 engineers over 9 months; and (2) conducted a controlled experiment on 3,000 synthetic composite commits from 10 diverse open-source projects. Results show that SmartCommit achieves a median accuracy between 71–84% when decomposing composite commits without developer involvement, and significantly helps developers follow the best practice of submitting activity-oriented commits with acceptable interaction effort and time cost in real collaborative software development.

In modern software development, developers rely on version control systems like Git to collaborate in the branch-based development workflow. One downside of this workflow is the conflicts occurred when merging contributions from different developers: these conflicts are tedious and error-prone to be correctly resolved, reducing the efficiency of collaboration and introducing potential bugs. The situation becomes even worse, with the popularity of refactorings in software development and evolution, because current merging tools (usually based on the text or tree structures of source code) are unaware of refactorings. In this paper, we present IntelliMerge, a graph-based refactoring-aware merging algorithm for Java programs. We explicitly enhance this algorithm's ability in detecting and resolving refactoring-related conflicts. Through the evaluation on 1,070 merge scenarios from 10 popular open-source Java projects, we show that IntelliMerge reduces the number of merge conflicts by 58.90% comparing with GitMerge (the prevalent unstructured merging tool) and 11.84% comparing with jFSTMerge (the state-of-the-art semi-structured merging tool) without sacrificing the auto-merging precision (88.48%) and recall (90.22%). Besides, the evaluation of performance shows that IntelliMerge takes 539 milliseconds to process one merge scenario on the median, which indicates its feasibility in real-world applications.

The conceptual model captures the key concepts in specific problem domains, as well as the important relationships between them. The quality of the conceptual model plays an important role for the success of software development. AAs restricted by personal knowledge and experience, a single modeler usually lacks of capability to build a high-quality conceptual model, especially when the problem domain has a high complexity. The large number of modelers online could help to solve this problem. However, the crowd modelers are temporal and topographical distributed and lack of interaction, which makes it hard for them modeling collaboratively. To address this problem, we developed a tool based on the stigmergy mechanism, which provides an indirect collaboration for online modelers. In this paper, we firstly introduce the architecture of our tool. Our tool helps to make up collaboration for those distributed online crowd through a merge-feedback process. Secondly, we introduce our entropy-based merging approach which is used to merge the models generated by different modelers. Two experiments are conducted to evaluate the feasibility of the merging approach and the stigmergy-based modeling tool.

The Internetware system is a complex and distributed self-adaptive system, which executes in an open, uncertain and dynamic environment, and adapts itself to changes in the environment. We hope that Internetware systems have the ability to automatically evolve in respond to changes. An important problem related to the development of Internetware systems is how to formulate proper adaptation rules. Because of the uncertainty of environment, the adaptation rules may not be suitable to the current system. Adaptation rules always need to be evolved to obtain better results. Some traditional methods can decide adaptation actions in different environmental conditions and evolve adaptation rules. But most of these methods bring about huge computation cost, which are not highly-efficient. To resolve these problems, we propose a method for evolving adaptation rules automatically, based on genetic algorithm and linear regression. We apply this method to evolve adaptation rules for a web application based on a widely used prototype --- RUBiS, which is an auction site similar to eBay. Experiments show that our method can evolve adaptation rules and improve the web application's performance in dynamic environment.

The conceptual model in software development captures the key concepts in specific problem domains, as well as the important relationships between them. The quality of the conceptual model plays an important role for the success of requirements engineering and software development. Generally, the quality of the conceptual model is restricted by modelers' personal knowledge and experience, and a single modeler usually possesses parts of the information that should be captured in a high-quality conceptual model, especially when the problem domain has a high complexity. To address this problem, we developed a tool named SCCMT, which provides an approach to modeling the conceptual model collaboratively with a large number of people, especially an online crowd. The main characteristic of this tool is twofold. (1) An indirect interaction mechanism is proposed to solve the communication problem among the temporal and topographical distributed online modelers. (2) A merge-feedback process is provided to inspire any single modeler in the crowd to improve her/his model based on the current modeling result of the crowd.

Crowdsourcing is used to obtain needed ideas and content by soliciting data from a large group of people, especially from an online community. However, the data generated by a group of people is duplicated. As to learn the crowd intention based on the crowd data, we need to do some entity resolution works. Previous works focus on data matching and merging, but remain far from perfect in crowdsourcing area. In our study, we propose a generic way in measuring and representing the crowd intention based on the crowd data. The main contribution of our study is twofold: 1. We propose a graph structure that represents the crowd intention. 2. We propose an entropy-based measurement that evaluates the diversity of the crowd intention.

Internetware denotes a type of complex distributed software system, which executes in an open, uncertain and dynamic environment, and adapts itself to changes in the environment. An important problem in the researches of Internetware is how to automatically construct the Internetware application that realizes the new requirements resulted from changes in the environment. In this paper, we focus on the automated construction of an important realization artifact of an Internetware application: the class diagram. A feature-driven approach is taken to automatically construct class diagrams. The approach consists of two components: a feature model utilized to model all the requirements that an Internetware application has to realize in different environments; the transformation rules from this feature model to class diagrams for automated class diagram construction. With this approach, once the requirements specific to an environment is given, the class diagram realizing the requirements can be constructed with the transformation rules automatically. To support the formal specification of the transformation rules, we design a transformation description language TDL4CD. Furthermore, several criteria for checking the validity of transformation rules written in TDL4CD is provided to support the construction of class diagrams. The usability of TDL4CD, as well as the feasibility of automatically constructing a class diagram with transformation rules in TDL4CD are preliminarily evaluated with 2 case studies.

The internetware system is a complex and distributed self-adaptive system, which challenges the method for making adaptation plans. Rule based approaches are very efficient to make plans in adaptive systems. To enable effective rule-based adaptation, we need to write a set of well behaved self-adaptive rules which could always lead to desirable states. This adaptive rules-set needs to be correct, com- plete, conflicts-free and well satisfy user goals, and it should updates according to user preferences. However, it is a difficult task for sys- tem users to define such a set of rules. To resolve this problem, we provide an rule generation engine, which could automatically generate well behaved self-adaptive rules according to user pref- erences. The rule generation engine is realized by a three-stage algorithm: stage 1 integrates user goals and user preferences, stage 2 establishes 1-1 tracing relationship between a context state and its desirable software configuration, stage 3 extracts self-adaptive rules from the tracing relationship between context states and software configurations. We will apply this engine to generate self-adaptive rules for a smart phone system, and evaluate the quality of generated self-adaptive rules.

Software product line engineering (SPLE) is a widely adopted approach to systematic software reuse. One basic research issue in SPLE is the product derivation problem, which focuses on how to derive software products from reusable software assets efficiently. In this paper, we focus on a sub-problem of product derivation: the problem of automated use case derivation, i.e. deriving the use cases of a software product in an automated way. We take a feature-oriented approach to this problem, an approach involving two components: a feature model, and the transformation information from the feature model to a set of use cases. In particular, we propose a transformation description language (TDL) to specify the transformation information from a feature model to a set of related use cases, and to support automated derivation of use cases corresponding to a valid feature model configuration. In addition, we also propose a set of criteria to check the validity of a TDL program. Three case studies have been conducted to demonstrate the usability of TDL and the feasibility of the automated use case derivation process based on TDL programs.

Integrating the computing process and the physical process, cyber-physical systems (CPS) pose many challenges to the system analysis and modeling. While most of the existing work focuses on developing the precise and formal model of CPS, little attentions have been given to the early requirements analysis and modeling which focuses on what the users' requirements are and what the software and physical domains of CPS will do to meet the users' requirements. In this paper, we provide an approach for early requirements analysis and modeling of CPS. This approach proposes to build the structure model to capture the system architecture, and the goal model to capture the refinement relationships between the users' requirements and the assumptions and requirements on the domains in CPS. These models help to build a clear understanding about CPS between the users and the designers and pave the way to define the precise and formal model. What these models are and how to build them are illustrated through a cruise control system.

On-Functional Requirements (NFRs) are vital for the success of software systems. Generally speaking, NFRs are some implicit expectations about how well the software will work, often known as software quality. For building better software, the NFRs should be considered as criteria for design decision. However, different NFRs may produce different criteria on the implementation strategies of the software functions. A trade-off analysis is needed for getting an optimal plan during design decision to satisfice NFRs as well as possible. By focusing on the NFRs that can be quantitatively specified, this paper proposes an approach to finding such an optimal solution for helping to make better decision. This approach regards the NFRs as the constraints on the implementation strategies of the software functions and models the selection of implementation strategies as a 0-1 programming problem. Then, a 0-1 programming solver can be used to find the optimal solution. An example is given to demonstrate the feasibility of this approach.

Internetware denotes a kind of complex distributed software system, which executes in an open, uncertain and dynamic environment, and adapts itself to changes in the environment. An important problem related to the development of Internetware applications is how to define their requirements. Traditional requirements modeling methods work well with software applications deployed in predictable environment, but cannot deal with Internetware applications, which have to identify and adapt themselves to the unpredictable situations of their environment. The self-adaptation characteristic of Internetware applications introduces challenges to the effective modeling of the requirements of Internetware applications. In this paper, we carry out a preliminary study on requirements modeling methods for self-adaptive software systems. In particular, we focus on how existing requirements modeling methods address the challenges caused by self-adaptation and what are the advantages and disadvantages of their solutions. By doing this study, we aim to identify the essential capabilities or properties that a requirements modeling method should possess so as to support the requirements modeling of self-adaptive software systems like Internetware.

Large modern software systems are often organized as product lines, requiring specialists to configure variability models before delivering a product. Variability models capture both the commonality and variability of different products, and help detect the configurations errors. Existing approaches can recommend fixes for the errors automatically. However, the recommended fixes are sometimes large and complex, and existing approaches lack guidance to help users identify a desirable fix. This paper proposes an approach to provide such guidance using dynamic priorities. The basic idea is to first generate one fix, and then gradually reach the desirable fix based on user feedback. To this end, our approach (1) automatically translates user feedback into a set of implicit priority levels on configuration variables, using five priority assignment and adjustment strategies and (2) efficiently generates potential desirable fixes by calculating new values for the variables with low priority. The experiments on real variability models show that we can reduce up to 89% of the fixes, and up to 98% of the variables shown to the user, compared to when no priorities are used.

Self-adaptive software systems can adjust their behaviors at runtime to respond to the context changes. To operationalize the adaptive mechanism, feedback loops have been advocated in many works. However, most of existing works focus on the architecture design to realize the feedback loops. How to model the required feedback loops remains an issue. In this paper, we propose a problem oriented approach for this issue. This approach models the system composed by the self-adaptive software and its context as an adaptive control system which is equipped with two kinds of feedback loops: context-aware feedback loops and requirements-aware feedback loops. To model the feedback loops, we identify five classes of software problems to address the different concerns of the adaptive requirements behind the feedback loops. We illustrate our idea by applying it to a cruise control system.

Computation offloading is a promising way to improve the performance as well as reducing the battery power consumption of a smartphone application by executing some parts of the application on a remote server. Supporting such capability is not easy for smartphone application developers due to (1) correctness: some code, e.g., that for GPS, gravity, and other sensors, can run only on the smartphone so that developers have to identify which parts of the application cannot be offloaded; (2) effectiveness: the reduced execution time must be greater than the network delay caused by computation offloading so that developers need to calculate which parts are worth offloading; (3) adaptability: smartphone applications often face changes of user requirements and runtime environments so that developers need to implement the adaptation on offloading. More importantly, considering the large number of today's smartphone applications, solutions applicable for legacy applications will be much more valuable. In this paper, we present a tool, named DPartner, that automatically refactors Android applications to be the ones with computation offloading capability. For a given Android application, DPartner first analyzes its bytecode for discovering the parts worth offloading, then rewrites the bytecode to implement a special program structure supporting on-demand offloading, and finally generates two artifacts to be deployed onto an Android phone and the server, respectively. We evaluated DPartner on three real-world Android applications, demonstrating the reduction of execution time by 46%-97% and battery power consumption by 27%-83%.

Feature-oriented analysis and modeling is widely accepted in software reuse, which consists of two major phases that should be taken seriously. The first is to construct a feature model, and the second is to configure products based on the feature model attained in the first. This paper presents a matrix-based approach to constructing and configuring feature models, whose main advantage is its scalability compared to traditional graphic-based feature models, and the supporting tool is presented to demonstrate its feasibility.

Feature models provide an effective way to organize and reuse requirements in a specific domain. A feature model consists of a feature tree and cross-tree constraints. Identifying features and then building a feature tree takes a lot of effort, and many semi-automated approaches have been proposed to help the situation. However, finding cross-tree constraints is often more challenging which still lacks the help of automation. In this paper, we propose an approach to mining cross-tree binary constraints in the construction of feature models. Binary constraints are the most basic kind of cross-tree constraints that involve exactly two features and can be further classified into two sub-types, i.e. requires and excludes. Given these two sub-types, a pair of any two features in a feature model falls into one of the following classes: no constraints between them, a requires between them, or an excludes between them. Therefore we perform a 3-class classification on feature pairs to mine binary constraints from features. We incorporate a support vector machine as the classifier and utilize a genetic algorithm to optimize it. We conduct a series of experiments on two feature models constructed by third parties, to evaluate the effectiveness of our approach under different conditions that might occur in practical use. Results show that we can mine binary constraints at a high recall (near 100% in most cases), which is important because finding a missing constraint is very costly in real, often large, feature models.

Feature models provide an effective way to capture commonality and variability in a specific domain. Constructing a feature model needs a systematic review of existing software artifacts in a domain and is always a collaboration-intensive activity. However, existing feature modeling methods and tools lack explicit support of such collaborations. In this paper, we present an environment for feature modeling that promotes the collaboration between stakeholders as the basis of creating and evolving a feature model. We present concepts, methods, and a tool to show the feasibility of constructing feature models collaboratively, as well as how to integrate this environment with traditional feature modeling methods.

In the software development, most stakeholders cannot clearly and objectively express their needs for the envisioned software systems. In this paper, we propose a problem-driven collaborative requirements elicitation approach, with the purpose of helping identify and extract the requirements of the Internetwares (a complex and new software paradigm). The basic idea of our approach is that the requirements of the software systems should be stated by stakeholders in an objective way (i.e. problem-identifying-solving way). That is, first identify the problems existed in the as-is problem domain, and then find the solutions to the problems. The solutions to the problems are the requirements of the envisioned software systems. To this end, we propose the structure of problems and a collaborative process for achieving the solutions.

Internetware is a paradigm of open, decentralized and continually evolvable software systems running on the Internet. In the development of Internetware, the enormous amount of its stakeholders brings challenges to the gathering of common and essential requirements among these stakeholders and continual evolution of the requirements. In this paper, we present a web-based collaborative feature modeling system (CoFM) developed as a platform for gathering, organizing, evaluating, and negotiating Internetware requirements. The basic idea is to express and organize requirements in terms of user-perceivable features of desired Internetware application, and to allow stakeholders to propose, evaluate and negotiate these features collaboratively, in a shared feature model of the application. During the collaboration, the application provider can discover the common and important features that need to be implemented at present, and the special but valuable features that might be provided in the future. Moreover, the provider can track the up-to-moment evolution of the features, which enables the provider to quickly respond to the changes in the Internetware requirements.

Dependability is gradually being recognized as an important issue for critical software systems. So far, there still lacks an effective approach for dependability requirements elicitation. This paper presents our work-in progress on an HAZOP-based approach (called DRE-HAZOP) to eliciting the dependability requirements in a systematical way.

Stakeholders play critical roles in requirements elicitation, since they are the source of requirements, and the quality of elicited requirements is significantly influenced by the degree of stakeholders' participation and collaboration in elicitation. However, requirements elicitation is often obstructed due to the diversity in stakeholders' background and interests, especially in the different perspectives on the envisioned systems, the insufficient communication and common-understanding among them, and the different abilities to express requirements.

In the research of software reuse, feature models have been widely adopted to organize the requirements of a set of applications in a software domain. However, there still lacks an effective approach to minimizing analysts' participation in feature models' construction. In this paper, we propose a use case based semi-automatic approach to the construction of feature models. The basic idea of this approach is to first construct a set of feature models for individual applications(called application feature models, AFMs) in a software domain, then adjust, and merge the set of AFMs to form a feature model for this domain (called a domain feature model, DFM). The main characteristic of this approach is that it provides a set of rules and algorithms to make the construction of AFMs (from use cases) and the construction of DFMs (by merging a set of AFMs) be carried out automatically. A running example is used to illustrate the main characteristic and the feasibility of this approach.

Identification of crosscutting concerns at the requirements level is important for the modularization and evolution of requirements, and has attracted many research interests. This paper proposes a feature-oriented approach to the identification of crosscutting requirements based on feature dependency analysis. In this approach, features are used as basic elements to organize the requirements space, and two kinds of dynamic dependencies (i.e. interactions and weavings) between features are analyzed to find out the candidate crosscutting requirements and their influence on other requirements. A case study is also used to illustrate the application of this approach

Feature models have been widely adopted in software reuse to organize the requirements of a set of similar applications in a software domain/product line. However, in most feature-oriented methods, the construction of feature models heavily depends on the domain analysts' personal understanding, and the work of constructing feature models from the original requirements of sample applications is often tedious and ineffective. This paper proposes a semiautomatic approach to constructing feature models based on requirements clustering, which automates the activities of feature identification, organization and variability modeling to a great extent. The underlying idea of this approach is to analyze the relationships between individual requirements and cluster tight-related requirements into features. With the automatic support of this approach, good quality feature models can be constructed in a more effective way. A case study is also provided to show the feasibility of this approach.

There are many researches on requirements dependencies. However, most of them limit their views to the requirements phase of software development, few focus on the roles of requirements dependencies in the solution space of software. This paper presents a feature-oriented approach to modeling requirements dependencies. A feature is a set of tight-related requirements from user/customer-views. The feature-orientation provides a modular way to organize requirements and a proper granularity to analyze requirements dependencies. In this approach, we care about not only static feature dependencies (i. e. refinements and constraints), but also feature dependencies at the specification level (namely influences) and, furthermore, dynamic feature dependencies (namely interactions). Moreover, we also explore the underlying connections between these four kinds of feature dependency. By this way, this approach gives a more complete view of how requirements dependencies influence the whole process of software development.

Getting a proper set of reusable requirements is an important milestone for successful software product line (SPL) practice. But modeling SPL requirements is usually more complex and difficult than modeling requirements for individual applications because it often involves systematically exploring commonality and variation across a set of applications. This paper presents a feature-oriented approach to modeling and reusing SPL requirements. A framework of the feature model is first proposed from five aspects, namely, basic structure, variation representation mechanism, variation binding time, variation constraint mechanism and quality feature analysis. Then, a customization-based reusing method is suggested, and a feature-oriented domain modeling method (FODM) is presented, including a concrete form of the feature model and a modeling process for it. At the end, a case study of a real domain is used to validate the feature model framework and demonstrate FODM.