Yunwen Ye

Toward an understanding of the motivation of open source software developers

An Open Source Software (OSS) project is unlikely to be successful unless there is an accompanied community that provides the platform for developers and users to collaborate. Members of such communities are volunteers whose motivation to participate and contribute is of essential importance to the success of OSS projects. In this paper, we aim to create an understanding of what motivates people to participate in OSS communities. We theorize that learning is one of the motivational forces. Our theory is grounded in the learning theory of Legitimate Peripheral Participation, and is supported by analyzing the social structure of OSS communities and the co-evolution between OSS systems and communities. We also discuss practical implications of our theory for creating and maintaining sustainable OSS communities as well as for software engineering research and education.

Meta-design: a manifesto for end-user development

End-user development (EUD) activities range from customization to component configuration and programming. Office software, such as the ubiquitous spreadsheet, provides customization facilities, while the growth of the Web has added impetus to end-user scripting for interactive functions in Web sites. In scientific and engineering domains, end users frequently develop complex systems with standard programming languages such as C++ and Java. However, only a minority of users adapt commercial off-the-shelf (COTS) software products. Indeed, composing systems from reusable components, such as enterprise resource planing (ERP) systems, defeats most end users who resort to expensive and scarce expert developers for implementation.

Reuse-Conducive Development Environments

Despite its well-recognized benefits, software reuse has not met its expected success due to technical, cognitive, and social difficulties. We have systematically analyzed the reuse problem (especially the cognitive and social difficulties faced by software developers who reuse) from a multidimensional perspective, drawing on our long-term research on information retrieval, human-computer interaction, and knowledge-based systems. Based on this analysis, we propose the concept of reuse-conducive development environments, which encourage and enable software developers to reuse through the smooth integration of reuse repository systems and development environments. We have designed, implemented, and evaluated CodeBroker—a reuse-conducive development environment—that autonomously locates and delivers task-relevant and personalized components into the current software development environment. Empirical evaluations of CodeBroker have shown that the system is effective in promoting reuse by enabling software developers to reuse components unknown to them, reducing the difficulties in locating components, and augmenting the programming capability of software developers.

Information delivery in support of learning reusable software components on demand

An inherent dilemma exists in the design of high-functionality applications (such as repositories of reusable software components). In order to be useful, high-functionality applications have to provide a large number of features, creating huge learning problems for users. We address this dilemma by developing intelligent interfaces that support learning on demand by enabling users to learn new features when they are needed during work. We support learning on demand with information delivery by identifying learning opportunities of which users might not be aware. The challenging issues in implementing information delivery are discussed and techniques to address them are illustrated with the CodeBroker system. CodeBroker supports Java programmers in learning reusable software components in the context of their normal development environments and practice by proactively delivering task-relevant and personalized information. Evaluations of the system have shown its effectiveness in supporting learning on demand.

A socio-technical framework for supporting programmers

Studies have shown that programmers frequently seek external information during programming, from source code and documents, as well as from other programmers because much of the information remains in the heads of programmers. Programmers therefore often ask other programmers questions to seek information in a timely fashion to carry out their work. This information seeking entails several conflicting factors. From the perspective of the information-seeking programmer, not asking questions degrades productivity. Conversely, asking questions interrupts other programmers and degrades their productivity, and may be frowned upon by peers due to the perceived social inconsideration of the information seeker. From the perspective of the recipients of the question, even though helping is costly, not helping also incurs social costs due to the deviation from social norms. To balance all these factors, this paper proposes the STeP_IN (Socio-Technical Platform for In situ Networking) framework to guide the design of systems that support information seeking during different phases of programming. The framework facilitates access to the information in the heads of other programmers while minimizing the negative impacts on the overall productivity of the team.

Designing for participation in socio-technical software systems

Participative software systems are a new class of software systems whose development does not end at the deployment but requires continued user participation and contribution. They need to provide both solutions to users and a participation framework that entails technical and social challenges. Metadesign is a promising approach to guide the development of participative software systems. Drawing on lessons learned from a systematic analysis of Open Source Software projects, this paper described general issues that need to be addressed to enable and encourage continued user participation during the meta-design process.

Promoting Reuse with Active Reuse Repository Systems

Software component-based reuse is difficult for software developers to adopt because first they must know what components exist in a reuse repository and then they must know how to retrieve them easily. This paper describes the concept and implementation of active reuse repository systems that address the above two issues. Active reuse repository systems employ active information delivery mechanisms to deliver potentially reusable components that are relevant to the current development task. They can help software developers reuse components they did not even know existed. They can also greatly reduce the cost of component location because software developers need neither to specify reuse queries explicitly, nor to switch working contexts back and forth between development environments and reuse repository systems.

Personalizing Delivered Information in a Software Reuse Environment

Browsing- and querying-oriented schemes have long served as the principal techniques for software developers to locate software components from a component repository for reuse. Unfortunately, the problem remains that software developers simply will not actively search for components when they are unaware that they need components or that relevant components even exist. Thus, to assist software developers in making full use of large component repositories, information access need to be complemented by information delivery. Effective delivery of components calls for the personalization of the components to the task being performed and the knowledge of the user performing it.We have designed, implemented, and evaluated the CodeBroker system to support personalized component delivery to increase the usefulness of a Java software reuse environment.

The Ecology of Participants in Co-evolving Socio-technical Environments

The traditional notions of developer and user are unable to reflect the fact that many software systems nowadays are developed with the participation of many people of different interests and capabilities. The sharp distinction between users and developers gets blurred. Many researchers have used different concepts such as end-user developer, prosumer, pro-am to describe those new in-between roles. This paper provides a conceptual framework for characterizing varied activities that all people involved in using and developing software systems from a socio-technical perspective. The conceptual framework clarifies the spectrum of different use and development activities by a continuum of participants with different roles. Based on the framework, we analyze how participants change their roles to migrate from users to developers through interactions, and how such interactions co-evolve both the community and software artifacts.

Context-aware browsing of large component repositories

The paper proposes a novel approach to locating software components from a large component repository: context-aware browsing. Without any explicit input from software developers, this approach automatically locates and presents a list of software components that could possibly be used in the current development situation. This automation of the component location process not only greatly reduces the search space of components so that software developers can easily browse and choose the desired components, but also enables software developers to use components whose existence they do not even anticipate. A software agent that supports context-aware browsing has been developed and evaluated.