Developers’ technical expertise is crucial for numerous tasks within open-source communities, such as identifying suitable developers and maintainers. Despite its significance, GitHub, the world’s largest open-source code hosting platform, does not explicitly display developers’ technical expertise. Existing methods fall short in capturing the multi-faceted and dynamic nature of developers’ skills and knowledge. To address this gap, we propose a novel approach that leverages graph neural networks (GNNs) to express developers’ technical expertise. Our method constructs a comprehensive GitHub social network that integrates various social and development activities. We then employ a GNN model to learn a low-dimensional representation vector for each developer, encapsulating their technical expertise across different dimensions. We assess the effectiveness of our model by comparing it against five baselines on three GitHub social relationship recommendation tasks, including SimDeveloper, ContributionRepo, and RepoMaintainer. Our proposed method outperforms these baselines, achieving improvements of 5.6–9.5% on Hit Ratio@10 and 3.4–11.1% on F1 score. These results demonstrate promising performance in predicting technical preferences for both repositories and developers. This research contributes to a more nuanced understanding of developer expertise in open-source communities and has potential implications for improving collaboration and project management on platforms like GitHub.

Currently, there are various scientific and technological resource retrieval databases in the world. The resources stored in these databases may be identified by different identification systems. How to determine whether scientific and technological resources identified by different identification systems are the same resource is an urgent problem to be solved. This paper proposes a software service that leverages BERT and large language models to perform semantic analysis and similarity matching of scientific and technological resource content, and then maps the resources to their respective identifiers. The service effectively solves the problem of how to quickly retrieve the same resource from a large number of scientific and technological resources with diverse identification types, and improves the efficiency and quality of the retrieval. Implemented as a Chrome plugin, the service facilitates seamless mapping heterogeneous scientific and technological resources to their identifiers. We conduct a series of experiments. Their results demonstrate the effectiveness, scalability and stability of the service. To the best of our knowledge, we are the first to propose the service integrating BERT with large language models to extract and identify the key content of scientific and technological resources from web pages.

N owadays, software service design is increasingly oriented toward addressing human needs, aiming to extract users' needs and behavioral patterns from open-source data. GitHub's massive open-source repositories have emerged as a crucial data source for software service researchers seeking to extract valuable insights and develop software services tailored for developers. Both GitHub and researchers are making efforts to help researchers and developers better utilize GitHub data. In 2017, GitHub launched “topics”, enabling developers to assign keywords to repositories. This feature fosters linkages between repositories, aiding in their discovery by other developers. For software development, topics offer two significant values. First, topics provide researchers with new insights to better mine GitHub data and provide enhanced support for developers. Second, developers utilizing topics to annotate their repositories may enhance their visibility and engagement within the community, potentially bolstering their repository's popularity. Despite the increasing number of topics, no research has systematically analyzed their content and potential value. Therefore, we conduct the first empirical study on topics, providing valuable conclusions for future researchers and developers. We conduct a case study encompassing 900 repositories to analyze the information explicitly presented in the topic content, and three experiments to verify whether topics have the potential to be used as repository features and user features in GitHub-related studies. Furthermore, we delve into the correlation between topics and repository popularity, by analyzing the number of stars repositories received. Our findings cover the composition of topic content, the potential value of topics for GitHub-related research, and the impact of topics on repository popularity.

Developers' technical expertise is crucial for various tasks within open-source communities, such as identifying suitable maintainers or reviewers. However, GitHub, the world's largest open-source code hosting platform, does not explicitly display developers' technical expertise. Existing methods fail to fully capture the multifaceted and dynamic nature of their skills and knowledge. To address this problem, we propose a novel approach to derive developers' technical expertise using graph neural networks (GNN). We construct a GitHub social network to integrate social and development activities and employ a GNN model to learn low-dimensional embedding for developers' technical expertise. We verify the effectiveness of our model on four GitHub social relationship recommendation tasks. The results demonstrate that our approach performs well in predicting technical preference for repositories and developers.

Before software developers actually start coding, an essential requirement is to be proficient in a programming language. However, as an important learning resource, programming language textbooks usually contain much about syntax and semantics of a programming language, but little about pragmatics, which is highly relevant with practical skills in solving real-world problems using programming languages. This makes it difficult for learners to transfer knowledge from textbooks to practice.To solve this problem, this paper proposes a programming language learning service, utilizing abundant development knowledge in Stack Overflow (SO) Q&A posts as the pragmatics knowledge of programming languages to make up for the shortage of pragmatics knowledge in textbooks. To link SO Q&A posts with textbooks, this paper first proposes a deep learning classification model to recognize SO posts containing development knowledge. Second, to align filtered SO posts with programming language learning processes, this paper proposes a weakly supervised link approach to matching SO posts with chapters and sections of textbooks. The feature of weak supervision ensures that the approach can be easily extended to other textbooks. Based on these modules above, this paper implements the programming language learning service in the form of a Chrome plugin. We conduct experiments and user study. Their results demonstrate the effectiveness, scalability and stability of the service.

Software developers are encouraged to reuse mature third-party code repositories to accelerate their developing. The first step is to find some code repositories which satisfy developers’ demand for specific functionality. Repository hosting platforms, such as GitHub, NPM, etc. are good search databases. However, these platforms provide little retrieval function based on repositories’ functional semantics, which is not conducive for developers to get desired code repository by claing what functionality they require.To solve this problem, we propose and implement an open- source repository retrieval service. First, to extract structured functional semantics of open-source repositories, we design a NER (Named Entity Recognition) model to extract features of six different dimensions related to software development. Next, we construct a HIN (Heterogeneous Information Network) to represent nonstructured semantic information of repositories. Finally, by combining two modules preceding, we implement an open-source repository retrieval service, in which a software developer only needs to tell the service what functionality he (or she) wants and will get a ranked list of repositories as return. We further conduct experiments and the results demonstrate the effectiveness of the service.

Open source is an important way for developers to collaborate on software development. More and more developers begin contributing to open-source projects. When a developer begins to contribute to an existing open source project, the first thing to do is to read and understand the project code. However, most current open source projects only provide API documentation, not project design documents for new developers. Developers can only understand the code based on scattered comments in the code, which are difficult for new comers. Therefore, developers need to find a learning path, which helps them understand the project and finish their contribution tasks quickly. In order to help developers find the learning path easily and quickly, this paper puts forward a method to automatically recommend learning paths of open source projects. It uses multiple data sources in an open source community to extract knowledge data and build knowledge graphs for open source projects. After that, based on a deep-learning-based knowledge graph embedding model and a path recommendation algorithm, the method recommends proper learning paths for developers. We select three well-known open source projects, including Lua, Memcached and TensorFlow, according to language, scope and community activity, as cases to verify our method, and do comparative experiments between the learning paths found by real developers and recommended by the method. Experiment results show that our method saves developers a lot of time while ensuring the accuracy of the recommended learning path.

Software development kits (SDKs) including application programming interfaces (APIs) are always required by developers who need to learn how to use the APIs. However, inexperienced developers may face two problems when learning APIs. Firstly, API-related learning resources cannot be easily obtained. Secondly, inexperienced developers often cannot find proper learning entries and paths to learn APIs, either. To solve these problems, we design an API learning service for inexperienced developers. Firstly, we propose an API link method to find learning resources about APIs in Stack Overflow (SO). Secondly, we construct an API knowledge graph which contains APIs and API-related Q&A threads from SO. Thirdly, by mining how APIs are discussed together in SO, we propose a learning entry recommendation method. At last, we propose an API learning service using the methods above to help inexperienced developers learn APIs. We conduct experiments and results demonstrate the feasibility of our methods and service.

GitHub is one of the largest hosting service platforms for software development, which contains more than 40 million users and 100 million software repositories. GitHub provides a trending page to help software developers discover potential repositories during a period of time. Also, GitHub introduces a feature named “topic” to label repositories. However, GitHub does not explicitly provide user preference information. It is difficult for software developers to find personalized GitHub trending repositories satisfying their preferences. In this paper, we propose a service named GHTRec to recommend personalized GitHub trending repositories for software developers. First, we use a deep-learning method to predict topics for GitHub repositories. Next, we leverage the historical repositories committed by software developers to make recommendation of GitHub trending repositories. Then we evaluate our topic prediction model and recommendation service, and results show that our GHTRec service could recommend trending repositories satisfying developers' topic preferences.

Urban region functions are the types of potential activities in an urban region, such as residence, commerce, transportation, entertainment, etc. A service which mines urban region functions is of great value for various applications, including urban planning and transportation management, etc. Many studies have been carried out to dig out different regions’ functions, but few studies are based on social media text analysis. Considering that the semantic information embedded in social media texts is very useful to infer an urban region’s main functions, we design a service which extracts human activities using Sina Weibo ( www.weibo.com ; the largest microblog system in Chinese, similar to Twitter) with location information and further describes a region’s main functions with a function vector based on the human activities. First, we predefine a variety of human activities to get the related activities corresponding to each Weibo post using an urban function classification model. Second, urban regions’ function vectors are generated, with which we can easily do some high-level work such as similar place recommendation. At last, with the function vectors generated, we develop a Web application for urban region function querying. We also conduct a case study among the urban regions in Beijing, and the experiment results demonstrate the feasibility of our method.

Urban region functions are the types of potential activities in an urban region, such as residence, commerce, transportation, entertainment, etc. A service which mines urban region functions is of great value for various applications, including urban planning and transportation management, etc. Many researches have been carried out to dig out different regions' functions, but few researches are based on social media text analysis. Considering that the semantic information embedded in social media texts is very useful to infer an urban region's main functions, we design a service which extracts human activities using Sina Weibo (the largest microblog system in Chinese, similar to Twitter) with location information and further describes a region's main functions with a function vector based on the human activities. Firstly, we predefine a variety of human activities to get the related activities corresponding to each Weibo post using an urban function classification model. Secondly, urban regions' function vectors are generated, with which we can easily do some high-level work such as similar place recommendation. At last, with the function vectors generated, we develop a web application for urban region function querying. We also conduct a case study among the urban regions in Beijing, and the experiment results demonstrate the feasibility of our method.

Developers usually learn excellent coding methods and design patterns by reading the code from well-known open-source projects, and participate in the development of open-source projects to enhance their programming capabilities. When developers have just joined an existing open-source project development, the first thing to do is to read and understand the project code. However, almost no project will maintain design documentations. Developers can only understand code according to user guide (mainly focus on how to use code but not on how to develop code) or brief code comments, which is relatively difficult for new developers. To help developers learn open-source projects more quickly, we propose an approach to helping developers learn open-source projects based on machine learning. First, we build a code structure graph for the project code by static analysis. Second, we implement a project entries recommendation approach based on clustering and machine learning to recommend project entries suitable for developers to read. Third, we implement a learning path recommendation algorithm. The algorithm recommends learning paths based on function nodes in the code structure graph selected by the developers, helps developers understand open-source projects better. In experiments, we select two famous c++ open-source projects, Lua and Memcache, as examples to perform project learning path recommendation. The experimental results show that our approach save a lot of time for developers to learn open-source projects while maintaining the accuracy of the recommendations.

Semantic code repair refers to automatically fix bugs where the actual program code compiles and executes successfully but fail to generate the output the programmer intends. This problem has not been solved very well so far. In this paper, we present a semantic code repair service using a deep attentional sequence-to-sequence model to predict related information about bugs and generate potential fixes without running the program actually. We evaluate the real performance of the semantic code repair service, and verify the feasibility and effectiveness of the service.

In order to help users get the source code in SO directly, this paper proposes a question-driven source code recommendation service based on the source code in Stack Overflow(SO). The service utilizes a question-code matching model to recommend users source code snippets which can solve the development problems users encounter. We evaluate the recommendation accuracy of the recommendation service and verify its feasibility. This service outperforms other approaches on recommendation accuracy, and the effectiveness of the service is also discussed.

This paper proposes a recommendation service for programming study based on Stack Overflow from the learners' point of view. The service consists of two parts: one is to preprocess and classify the questions in Stack Overflow, and it divides all the questions into six categories according to the learners' perspective; the other part is a learning recommendation mobile application based on the data of the existing classification, historical learning data of learners, etc. We evaluate the real performance of the recommendation service, and verify the feasibility and effectiveness of the service.

Abstract In distributed and open environments, MASs (multiagent systems) generally have no mechanisms for prior coordination and self‐organization has been believed to be the necessary selection to achieve the coordination of agents. This paper first presents a values‐driven model for self‐organization in which the expected emergent properties of a system are specified as the social values while the social values are realized via implicitly inducing members to regulate their individual values and adjust their behaviors to fit the expectations of the system. Based on the values‐driven self‐organization, this paper proposes an automated coordination mechanism for decentralized MASs. In this mechanism, by indirectly changing the difficulties in acquiring resources (which may be delegated to some special agents since MASs generally do not have substantial bodies), MASs can lead agents to regulate their values to be consistent with the social values of MASs so that the coordination of MASs can spontaneously emerge from the local behaviors of agents. Finally, this paper implements a simulation traffic system using the coordination mechanism based on values‐driven self‐organization to validate the emergence of coordination among multiple agents.

In express delivery, couriers will generate a mass of trajectory logs when delivering shipments. To analyze these logs is of great value for the promotion of express delivery service. For any research based on trajectory data, map-matching plays an important role, so in this article, we design a map-matching service specially for courier trajectories. As far as we know, existing map-matching algorithms are designed mainly for cars or walks, or ignoring means of transportation. Although these methods can be applied to courier trajectory map-matching, the accuracy of them can hardly be guaranteed as they ignore the characteristics of courier trajectories. To solve this problem, we design a new map-matching service based on a map-matching algorithm called Courier Trajectory Based Map-Matching (CTB-Matching), which is specially used to deal with courier trajectories. Courier trajectories have some characteristics different from traditional trajectories. Firstly, couriers have to deliver shipments at different sites, so the trajectories seem more irregular, which is called as "fragmentation" problem. Secondly, unlike cars, couriers' positioning information is mainly generated by Wi-Fi location system, which is not precise as Global Position System (GPS), so the location deviation problem should be taken into account. What's more, couriers usually use electric bikes for delivery, which travel slower than cars, and are less likely to be influenced by traffic. Therefore, the speed or temporal analysis for cars is not suitable here. Based on the analysis of current algorithms and the problems stated above, this paper designs a map-matching service for courier trajectory data. The experiments verify that our service performs better when dealing with courier trajectory data. Besides, our service is efficient with low time complexity and space complexity, making our service responses with low latency.

MOOCs are popular for online education because of its convenience and excellent educational resources. At present, MOOCs just provide very limited online practical environments such as online tests, quizzes and online judge etc., but they have not provided students with some dynamic and operable online practical environments, such as interactive education tools etc. Online education tools can satisfy the needs of online practicing, mainly because of its abundance, interactivity and convenience, but MOOCs have not made full use of these online tools yet. The paper proposes an approach to using existing online education tools to support practical education on MOOCs by two enhancements: educational resources development and real-time collaborative learning. The key to the approach is operation reuse, which involves recording, optimizing and replaying user operations on existing online educations tools. Based on the approach, we develop an education platform called Smart Web Tutor. Case study is performed to analyze user experience, and the results show that our approach contributes to students' learning, especially for real-time collaborative learning. Also, some suggestions from students are inspiring to further increase the utility and user experience of our approach and education platform.

With the increasing demand for express delivery, a courier needs to deliver many tasks in one day and it's necessary to deliver punctually as the customers expect. At the same time, they want to schedule the delivery tasks to minimize the total time of a courier's one-day delivery, considering the total travel time. However, most of scheduling researches on express delivery focus on inter-city transportation, and they are not suitable for the express delivery to customers in the “last mile”. To solve the issue above, this paper proposes a personalized service for scheduling express delivery, which not only satisfies all the customers' appointment time but also makes the total time minimized. In this service, personalized and accurate travel time estimation is important to guarantee delivery punctuality when delivering shipments. Therefore, the personalized scheduling service is designed to consist of two basic services: (1) personalized travel time estimation service for any path in express delivery using courier trajectories, (2) an express delivery scheduling service considering multiple factors, including customers' appointments, one-day delivery costs, etc., which is based on the accurate travel time estimation provided by the first service. We evaluate our proposed service based on extensive experiments, using GPS trajectories generated by more than 1000 couriers over a period of two months in Beijing. The results demonstrate the effectiveness and efficiency of our method.

Web-based IDEs are more and more popular because developers can create or modify software artifacts in the browser without need to install any local development tool and spend valuable development time on system setup and maintenance. For those development tasks using a Web-based IDE, such as configuring programming context and batch test etc., some are frequent and repetitive because they are similar from project to project. Automating the repetitive tasks on Web-based IDEs, regardless of their complexity, would reduce the amount of work that developers must perform to complete the tasks, which would improve the development efficiency of Web applications. In this paper, we put forward a user-friendly approach to automating repetitive tasks on existing Web-based IDEs. The key to the approach is to extend the basic Web-based capture-replay technique with editable and reusable features, which are necessary for automation because some operations are redundant, as well as developers should recognize and define repetitive tasks. Moreover, we develop a supporting tool for the approach. In the case study, we introduce how the approach is used to support automating repetitive tasks on Web-based IDEs. Case studies verify that the approach can improve the development efficiency very well.

Online education plays a more and more important role in the era of Internet and cloud computing, but two problems remain unsolved including MOOCs. First, most of existing online education platforms only provide teaching materials in format of ppt, pdf, video, and they seldom support education based on graphical Web applications. Second, some online education platforms may provide self-governed chatting tools or whiteboards, but they are not combined with teaching materials closely. As a result, they cannot satisfy the need for the real-time interactions based on complex teaching materials. To solve the problems above, we put forward an online education approach using Web operation record and replay techniques, and implement online synchronized education and real-time interactions between teachers and students. Moreover, we develop a supporting tool OSEP for the approach. In the case study, we describe three education scenarios, which verify that the approach supports not only personal learning by tutorials and wizards, but also online in-class real-time collaborative learning.

This paper presents SMoCoR, a smart mobile contact recommender based on smart phone data. It recommends the most appropriate way to contact friends according to friends' current condition. In no emergency condition, SMoCoR achieves two goals. First, the recommended contacts disturb friends least, that means, it will tell whether it's suitable to call friends. Second, the recommended contact makes the communication information accessible to the friends and gets replies from the friends as soon as possible. For the goals above, SMoCoR takes friends' calendar data and smart phone data as inputs, and after several steps of calculation it will recommend a list of contacts ranked by intelligent algorithm according to the appropriateness. The experimental results based on real-user data show that SMoCoR provides an efficient and accurate means for contact recommendation.

This paper presents SMoCoR, a smart mobile contact recommender based on smart phone data. It recommends the most appropriate way to contact friends according to friends’ current condition. In no emergency condition, SMoCoR achieves two goals. First, the recommended contacts disturb friends least, that means, it will tell whether it’s suitable to call friends. Second, the recommended contact makes the communication information accessible to the friends and gets replies from the friends as soon as possible. For the goals above, SMoCoR takes friends’ calendar data and smart phone data as inputs, and after several steps of calculation it will recommend a list of contacts ranked by intelligent algorithm according to the appropriateness. The recommendation includes two aspects. Firstly, SMoCoR recommends whether it is suitable to make calls, which is named call recommendation. Secondly, SMoCoR recommends a list of the ranked text contacts, which is named text contact recommendation. The experimental results based on real-user data show that SMoCoR provides an effective method for contact recommendation.

Many programs access external data sources through generic APIs. The class hierarchy of such a generic API does not reflect the schema of any particular data source, and thus it is hard to clarify what data an API client accesses and how it obtains them. This makes it difficult to maintain the API clients. In this paper, we show that the data access of an API client can be recovered through static analysis on the client's source code. We provide a formal and intuitive way to represent the data access, as a graph of so-called summoning snippets. Each snippet stands for a type of data accessed by the client, and carries the code slice from the client about how to obtain the data via the API. We provide an automated approach to inferring a complete and well-simplified set of summoning snippets from the client source code, based on points-to analysis and code slicing. We implement this approach as a development assistant tool, and evaluate it on eight open source data processing programs, with average precision and recall of 89% and 95%, respectively. Further inspection of these clients, as well as a user study about writing data accessing code on their data sources, show that the inference results are useful in the inspection of existing clients and the development of new data access logics.

With the increasing complexity of enterprise applications, it becomes very challenging to create software systems which can exhibit a satisfactory performance behavior. In current system development practice, it often inevitably exists some "anti-patterns", which usually impede the performance or maintainability of software systems. Manually investigating anti-patterns in systems is a time-consuming and labor intensive task. To deal with this problem, we propose a general anti-pattern detection approach for Java EE application. Firstly, we propose a Java EE meta-model, based on which, we use QVT language to specify the detection process of anti-patterns. Secondly, we implement our approach on a runtime architecture-based reflective framework. When a Java EE application runs on one of the supported application servers, we can execute QVT script to detect whether or not there exists a specific anti-pattern in current system and get the report of potential problem components. At last, we perform a case study based on 35 well-known anti-patterns to evaluate the effectiveness and applicability of our approach.

Software Engineering is important for the students majored in computer science and technology. This curriculum is intended to provide students with an overall view over Software Engineering as an engineering discipline and with insight into the processes of software development. Creating software Engineering curriculum faces several challenges: (1) Software Engineering has wide coverage, but teaching time is limited. So it is difficult to make in-depth education. (2) Some introductory Software Engineering courses present the principles in isolation from practice. Teaching the lectures seems to focus on philosophy and methodology level, which leads to difficulty for students having no practical experience to understand. (3) Due to the lack of software project practice, students can hardly apply appropriate software engineering methods and technologies to solve problems. (4) How can Software Engineering curriculum satisfy the various needs of different levels? This paper focuses on the challenges above, and introduces how to try to solve them by a case study on the construction of Software Engineering curriculum at Peking University. Finally, this paper gives the future direction for the construction of Software Engineering curriculum.

The way to document architecture is called Architecture Description (AD). It contains all the key design decisions, presents how the system is composed, specifies the interface of the component, and etc. Such information is needed not only during the whole development but also in the system maintenance or evolvement phase. Meanwhile, the amount of the various ADs in a modern software system becomes very large and the content of ADs is also richer. To understand the system ADs becomes challenging to the engineers. However, past research in the software engineering area did not pay enough attention to assisting the engineers to understand the ADs. On the other hand, according to the document navigation research in Human Computer Interaction (HCI), the engineer's intention should be adequately presented. To address these issues, we proposed a Task-oriented Navigation Approach and developed a tool support. By specifying tasks that express the purpose of the engineer, our approach generates the organized information, trims the irrelevant descriptions, and guides the navigation sequentially. Our approach provides several major benefits. First, it offers an approach to capture the purpose of the engineer. Second, it reminds the engineer about the possible omission during the reading. Last, it improves the understandability of the AD and reduces the workload of the engineer.

Runtime models represent the dynamic data of running systems, and enable developers to manipulate the data in an abstract, model-based way. This paper presents [email protected], a tool that help realize runtime models on a wide class of systems. Receiving a meta-model specifying the target system's data type and an API description specifying how to manipulate the data, [email protected] automatically generates the synchronizer to maintain the runtime model for this system.

With the increasing maturity of model-driven tools and methods, new model-based analysis methods are developed to support specific stakeholder concerns during software lifecycle. This multiplication of models and their related analysis tools calls for solution addressing the integration of MOF-based analysis methods. Current research works on integration of analysis methods have already addressed the extraction of the needed input data as well as the control and the integration of the tools supporting the analysis execution. However, little attention has been paid to the integration of analysis results back into initial model. We propose a MOF-based framework enabling the integration of analysis results that a) defines a meta-model capturing the integration requirements, b) provides a MOF meta-model extension mechanism with support for upward compatibility; and c) automatically generates a model transformation for model integration. We illustrate the use of our framework by integrating a reliability analysis methods and a fault tolerant reconfiguration method on the ABC/ADL Software Architecture. We applied the resulting analysis composition onto the ECPerf JEE system.

Software architectures are considered the key means to manage the complexity of large-scale systems from the high abstraction levels and system-wide perspectives. The traditional software design methodologies and the emerging architecture design methods still fall short of coping with the architectural complexity and difficulty in practice. The recent research on the architecture design decisions mostly focuses on its representation, providing little support for the architecture design task itself. In this paper we propose a decision-oriented architecture design approach ABC/DD, based on the decision-abstraction and issue-decomposition principles specific to the architecture level design of software. The approach models software architecture from the perspective of design decisions, and accomplishes the architecture design from eliciting architecturally significant design issues to exploiting and making decisions on the solutions for these issues. We illustrate the application of the approach with two real-life large-scale software-intensive projects, showing that the decision-oriented approach accommodates the characteristics and demands of the architecture level, and facilitates the design of architecture and the capture of the essential decisions for large complex systems.

Software architectures are considered crucial because they are the earliest blueprints for target products and at the right level for achieving system-wide qualities. Existing methods of architecture design still face the challenge of bridging the gap between software requirements and architectures in practice. The emerging methods that focus on design decisions and rationale provide little support for deriving target architectures. In this paper we propose a decision- centric architecture design approach, which models issues, solutions, decisions, and rationale as the core elements of architecture design and the key notions to direct the derivation of target architectures. The approach transits from requirements to architectures through a process including issue eliciting, solution exploiting, solution synthesizing, and architecture deciding. We implement the automated synthesis of candidate architecture solutions from various issue solutions, and provide a way to capture comprehensive design decisions and rationale during this design process. We finally illustrate the applicability of this approach with a case study.

Model refinement is a complex task. It is difficult for developers to refine models all by themselves. A good modeling tool should not only do routine refinement work for developers, but also guide them to make decisions during the refinement process. Such refinement work is best done by modeling tools instantly while developers refine models, to provide timely assistance. In this paper, we present a general approach for meta-model designers or experts in different fields to define and describe such automatic refinement work by rules, and these rules can instruct the modeling tool to do the refinement work instantly, whenever the developers modify the model. The automatic refinement rules in our approach are based on OCL, and their semantics and behaviors are formally defined by using Dijkstra's guarded commands, so the rules are compact, unambiguous and reliable to use. We have also implemented the editor and the interpreter for the automatic refinement rules, and integrated them into our own modeling tool to support our approach.

Mission-critical software claims safe and robust adaptations that comply with rigorous criteria of multiple critical quality attributes. Existing adaptation approaches pay little attention to comprehensively capture mission goals and explicitly specify adaptation requirements. We propose an approach to using scenario-based analysis to elicit and specify the criteria of multiple quality attributes as adaptation invariants, and design corresponding architecture variants as facilities implementing adaptations. We also present how to make adaptation decisions at runtime.

The continuous requirements of evolving a delivered software system and the rising cost of shutting down a running software system are forcing researchers and practitioners to find ways of updating software as it runs. Dynamic update is a kind of software evolution that updates a running program without interruption. This paper covers the fundamental issues of the mechanisms of dynamic update theoretically. Based on a similarity analysis of many typical approaches to dynamic update during the past decades, we propose a unified formal model (namely, Dynamic Update Connector) to specify mechanisms of updating an architectural component, and reason about its properties. The model borrows the concept of connectors from software architecture community and is specified using process algebra CSP. We also demonstrate the applications of our DUC model.