Fuqing Yang

SNIAFL: Towards a static noninteractive approach to feature location

To facilitate software maintenance and evolution, a helpful step is to locate features concerned in a particular maintenance task. In the literature, both dynamic and interactive approaches have been proposed for feature location. In this paper, we present a static and non-interactive method for achieving this objective. The main idea of our approach is to use the information retrieval (IR) technology to reveal the basic connections between features and computational units in source code. Due to the characteristics of the retrieved connections, we use a static representation of the source code named BRCG to further recover both the relevant and the specific computational units for each feature. Furthermore, we recover the relationships among the relevant units for each feature. A premise of our approach is that programmers should use meaningful names as identifiers. We perform an experimental study based on a GNU system to evaluate our approach. In the experimental study, we present the detailed quantitative experimental data and give the qualitative analytical results.

SNIAFL: towards a static non-interactive approach to feature location

To facilitate software maintenance and evolution, a helpful step is to locate features concerned in a particular maintenance task. In the literature, both dynamic and interactive approaches have been proposed for feature location. In this paper, we present a static and non-interactive method for achieving this objective. The main idea of our approach is to use the information retrieval (IR) technology to reveal the basic connections between features and computational units in source code. Due to the characteristics of the retrieved connections, we use a static representation of the source code named BRCG to further recover both the relevant and the specific computational units for each feature. Furthermore, we recover the relationships among the relevant units for each feature. A premise of our approach is that programmers should use meaningful names as identifiers. We perform an experimental study based on a GNU system to evaluate our approach. In the experimental study, we present the detailed quantitative experimental data and give the qualitative analytical results.

Runtime recovery and manipulation of software architecture of component-based systems

Recently, more attention is paid to the researches and practices on how to use software architecture in software maintenance and evolution to reduce their complexity and cost. The key in such architecture-based maintenance and evolution is to recover software architecture from existing systems. Almost all studies on architecture recovery focus on analyzing the source code and other documents. Such recovered software architecture can hardly capture runtime states and behaviors of the system. At the same time, current work pays little attention on how to change the system directly via manipulating the recovered software architecture. This paper presents a novel approach to recovering software architecture from component based systems at runtime and changing the runtime systems via manipulating the recovered software architecture. Containing much more details than the designed software architecture, the recovered software architecture can accurately and thoroughly describe the actual states and behaviors of the runtime system. It can be described formally with the extension of traditional architecture description language, which enables the recovered software architecture to absorb the semantics embedded in the designed software architecture. The recovered software architecture can be represented as multiple views so as to help different users to control the complexity from different concerns. Based on the reflective ability of the component framework, the recovered software architecture is up-to-date at any time and changes made on it will immediately lead to the corresponding changes in the runtime system. The approach presented in this paper is demonstrated on PKUAS, a reflective J2EE (Java 2 Platform Enterprise Edition) application server, and the performance is also evaluated.

Technical framework for Internetware: An architecture centric approach

Being a new software paradigm evolved by the Internet, Internetware brings many challenges to the traditional software methods and techniques. Sponsored by the national basic research program (973), researchers in China have developed an architecture centric technical framework for the definition, incarnation and engineering of Internetware. First of all, a software model for Internetware is defined for what to be, including that Internetware entities should be packaged as components, behaving as agents, interoperating as services, collaborating in a structured and on demand manner, etc. Secondly, a middleware for Internetware is designed and implemented for how to be, including that Internetware entities are incarnated by runtime containers, structured collaborations are enabled by runtime software architecture, Internetware can be managed in a reflective and autonomic manner, etc. Thirdly, an engineering methodology for Internetware is proposed for how to do, including the way to develop Internetware entities and their collaborations by transforming and refining a set of software architectures which cover all the phases of software lifecycle, the way to identify and organize the disordered software assets by domain modeling, etc.

A software configuration management model for supporting component-based software development

Software configuration management (SCM) is viewed as an important key technology in software development and is being adopted in software industry more and more widely. And component-based software development (CBSD) is an emerging paradigm in software development. However, the traditional SCM method can not support CBSD effectively and efficiently. In this paper, we analyze the objects that need to be managed in CBSD and present a component-based SCM model to improve CBSD with effective SCM support. In this model, components, as the integral logical constituents in a system, are managed as the basic configuration items in SCM, and relationships between/among components are defined and maintained, in order to support version control of large objects and logical modeling of system architecture. Also some key issues in the model are discussed and an SCM system that supports this model is introduced.

APIExample: An effective web search based usage example recommendation system for java APIs

Programmers often learn how to use an API by studying its usage examples. There are many usage examples scattered in web pages on the Internet. However, it often takes programmers much effort to find out the desired examples from a large number of web pages by web search. This paper proposes a tool named APIExample that can extract usage examples for java APIs from web pages on the Internet and recommend them to programmers. Given a java API, the tool collects its related web pages from the Internet, extracts java code snippets and their surrounding descriptive texts embedded in the pages, then assembles them into usage examples for programmers. Furthermore, in order to help programmers capture more kinds of usages of the target API by browsing fewer examples, our tool clusters and ranks the listed examples based on the target APIs usage. Besides, as a practical tool, APIExample provides multiple aspects of frequently-used information about using the target API in a concise user interface with friendly user experience. Two kinds of user-interaction style, a web search portal and an Eclipse plug-in, are now both publicly available.

Relevancy based semantic interoperation of reuse repositories

Software reuse is a promising solution to the software crisis. Reuse repositories are the basic infrastructure for software reuse. During the past decade, various academic, commercial, governmental, and industrial organizations have developed many Internet-enabled reuse repositories to provide access to software components and related resources. It has necessitated semantic interoperation to allow distributed maintenance and management of these repositories while enabling users to efficiently and conveniently access resources from multiple reuse repositories via a single representation view. In this paper, we have proposed an approach to enhancing the semantic interoperability of reuse repositories, called the improved relevancy matching and ranking (IRMR) method, based on analyzing the correlation of terms in representation methods of the repositories. A prototype system, the Virtual Repository supporting Semantic Interoperation (VRSI), is presented to illustrate the application of this approach to support the semantic interoperation of reuse repositories. Experimental results on real world reuse repositories demonstrated significant improvement in terms of searching effectiveness.

Runtime software architecture based software online evolution

Runtime environment of software are becoming more and more dynamic and changeful, while pervasive computing and Web services further this situation. Software systems are not only becoming larger, more complex, and also more rigid, which make it difficult to evolve software. This paper focuses on online evolution, more exactly, how to make online evolution process convenient and smart, with help of runtime software architecture (RSA). Following issues are discussed in this paper: types of software environment changes, the incarnation of RSA, retrieval and manipulation of RSA, the relation between RSA and the runtime system, and a visual tool to show RSA, and make evolution process more easy and intuitionist.

An application server to support online evolution

Most online evolution of an application depends on its runtime environment. This paper addresses how to support online evolution by an application server, which is considered as a third kind of system software, besides OS and DBMS. From the view of requirements, evolutions of software can be divided into four categories: evolutions that do not alter requirements, evolutions that alter functional requirements, evolutions that alter local constraint requirements, and evolutions that alter global constraint requirements. All changes at the requirement level should be mapped to changes at the implementation level. In our approach implementation level entities, such as components and interceptors are responsible for online evolution. Evolutions in implementation level include adding, removing, updating, and reconfiguring the entities. One of the keys to our approach is to carefully distinguish states of components and interceptors, that is, whether they are in a ready, active, executing or evolving state. A well-designed architecture and feasible mechanisms for runtime instance loading are also keys to the solution. Based on this approach, an application server prototype, named PKUAS, has been implemented and is introduced in our paper.

Development of software engineering: co-operative efforts from academia, government and industry

In the past 40 years, software engineering has emerged as an important sub-field of computer science. The quality and productivity of software have been improved and the cost and risk of software development been decreased due to the contributions made in this sub-field. The software engineering community needs to invest much more efforts to cope with the drastically increasing demands on the information technology as well as the extremely open and dynamic nature of the Internet. The history of software engineering is reviewed with emphasis on the driving forces of software and the milestones of software engineering development. The history of software engineering in China is reviewed with emphasis on the relationship between software engineering and the software industry. Based on the above reviews, we argue that software engineering should become an independent discipline along with computer science and co-operative efforts from academia, governments and industries should be needed for the harmonious development of software engineering. Some results are presented based on Chinas experience of developing software engineering under this model.