An Exploratory Study of How Developers Seek, Relate, and Collect Relevant Information during Software Maintenance Tasks

Much of software developers' time is spent understanding unfamiliar code. To better understand how developers gain this understanding and how software development environments might be involved, a study was performed in which developers were given an unfamiliar program and asked to work on two debugging tasks and three enhancement tasks for 70 minutes. The study found that developers interleaved three activities. They began by searching for relevant code both manually and using search tools; however, they based their searches on limited and misrepresentative cues in the code, environment, and executing program, often leading to failed searches. When developers found relevant code, they followed its incoming and outgoing dependencies, often returning to it and navigating its other dependencies; while doing so, however, Eclipse's navigational tools caused significant overhead. Developers collected code and other information that they believed would be necessary to edit, duplicate, or otherwise refer to later by encoding it in the interactive state of Eclipse's package explorer, file tabs, and scroll bars. However, developers lost track of relevant code as these interfaces were used for other tasks, and developers were forced to find it again. These issues caused developers to spend, on average, 35 percent of their time performing the mechanics of navigation within and between source files. These observations suggest a new model of program understanding grounded in theories of information foraging and suggest ideas for tools that help developers seek, relate, and collect information in a more effective and explicit manner     

Multi-dimensional information-driven many-objective software remodularization approach

Most of the search-based software remodularization (SBSR) approaches designed to address the software remodularization problem (SRP) areutilizing only structural information-based coupling and cohesion quality criteria. However, in practice apart from these quality criteria, there require other aspects of coupling and cohesion quality criteria such as lexical and changed-history in designing the modules of the software systems. Therefore, consideration of limited aspects of software information in the SBSR may generate a sub-optimal modularization solution. Additionally, such modularization can be good from the quality metrics perspective but may not be acceptable to the developers. To produce a remodularization solution acceptable from both quality metrics and developers’ perspectives, this paper exploited more dimensions of software information to define the quality criteria as modularization objectives. Further, these objectives are simultaneously optimized using a tailored many-objective artificial bee colony (MaABC) to produce a remodularization solution. To assess the effectiveness of the proposed approach, we applied it over five software projects. The obtained remodularization solutions are evaluated with the software quality metrics and developers view of remodularization. Results demonstrate that the proposed software remodularization is an effective approach for generating good quality modularization solutions.     

Packaged software: implications of the differences from custom approaches to software development

This paper contributes to the literature on software development in two ways. First, by discussing the packaged software domain relative to the more commonly studied custom information systems (IS) domain. Second, this paper presents our speculations on the implications of these differences between packaged and custom IS development. Regarding the first issue, while the two domains share many commonalities, the differences are also important to understand. To make this clear we discuss the differences at four levels: industry forces, approaches to software development, work culture and development team efforts. At each level, data from three case studies are used to illustrate the differences between the two domains. To develop our speculations, we contend that the differences between packaged software and the traditional, custom, approach to information systems development will be profound for five stakeholder groups: software development organizations, software development teams, software developers, software consumers and for researchers interested in software development.     

基于社会-技术属性的软件服务活跃度分析

开源环境下,软件作为一类粗粒度的服务供用户使用和二次开发,其活跃程度反映了软件服务的发展状态,理解影响软件服务活跃度的因素是提高社区软件服务质量至关重要的一步。以SourceForge开源社区为研究对象,以软件服务的下载量、页面规模和点击量作为衡量软件服务活跃度的指标,分别从社会 技术属性角度来探究对开源软件服务的活跃度影响。研究结果表明：（1）软件服务要取得较好的活跃度,在核心人员组织上要规模适当（17人左右）,为确保成员的实际贡献力度,可同时参与的软件服务控制在7个以内,成员的角色应尽可能多且分布越均匀越好;（2）越成熟的软件服务倾向于越活跃,而其他技术属性的影响差异不明显且与它们的流行度无关,但它们的多样性与软件服务活跃度呈显著线性相关。     

On The Roles of APIs in the Coordination of Collaborative Software Development

The principle of information hiding has been very influential in software engineering since its inception in 1972. This principle prescribes that software modules hide implementation details from other modules in order to reduce their dependencies. This separation also decreases the dependency among software developers implementing these modules, thus simplifying the required coordination. A common instantiation of this principle widely used in the industry is in the form of application programming interfaces (APIs). While previous studies report on the general use and benefits of APIs, they have glossed over the detailed ways in which APIs facilitate the coordination of work. In order to unveil these mechanisms, we performed a qualitative study on how practitioners use APIs in their daily work. Using ethnographic data from two different software development teams, we identified three roles played by APIs in the coordination of software development projects. These roles are described using three metaphors: APIs as contracts, APIs as boundaries, and APIs as communication mechanisms. As contracts, APIs allow software developers to work in parallel and independently. As a communication mechanism, APIs facilitate communication among software developers by giving them something specific to talk about. At the same time, APIs establish the boundaries between developers, and, accordingly, what should be talked about. This paper also reports on problems the studied teams face when using APIs to coordinate their work. Based on these results, we draw theoretical implications for collaborative software engineering.     

Detecting Coordination Problems in Collaborative Software Development Environments

Software development is rarely an individual effort and generally involves teams of developers collaborating to generate good reliable code. Among the software code there exist technical dependencies that arise from software components using services from other components. The different ways of assigning the design, development, and testing of these software modules to people can cause various coordination problems among them. We claim that the collaboration of the developers, designers and testers must be related to and governed by the technical task structure. These collaboration practices are handled in what we call Socio-Technical Patterns.

The TESNA project (Technical Social Network Analysis) we report on in this paper addresses this issue. We propose a method and a tool that a project manager can use in order to detect the socio-technical coordination problems. We test the method and tool in a case study of a small and innovative software product company.     

Development of a peer-to-peer information sharing system using ontologies

Most existing agent-oriented methodologies ignore system extensibility, interoperability and reusability issues. Ontologies have been found to play a significant role in facilitating interoperability, reusability, MAS development activities (including MAS analysis and agent knowledge modeling) and MAS run-time operation (including agent communication and reasoning). However, most of the existing AOSE methodologies do not provide support for ontology-based MAS development. We present software engineering requirements for ontology-based development for MAS and examine an existing methodology, MOBMAS – a “Methodology for Ontology-Based MASs”, which makes use of ontologies as a modeling tool. In this examination, we highlight how MOBMAS can be extended to utilizing ontology roles in facilitating interoperability, reusability and verification. This will be based on using MOBMAS to develop peer-to-peer (P2P) community-based information sharing application which lead us to identify ontology related steps that can be added to enhance MOBMAS. MOBMAS is used by two experienced software developers who were not authors of the methodology, to guide the development of the P2P application.     

Refining code ownership with synchronous changes

When mining software repositories, two distinct sources of information are usually explored: the history log and snapshots of the system. Results of analyses derived from these two sources are biased by the frequency with which developers commit their changes. We argue that the usage of mainstream SCM (software configuration management) systems influences the way that developers work. For example, since it is tedious to resolve conflicts due to parallel commits, developers tend to minimize conflicts by not contemporarily modifying the same file. This however defeats one of the purposes of such systems. We mine repositories created by our tool Syde, which records changes in a central repository whenever a file is compiled locally in the IDE (integrated development environment) by any developer in a multi-developer project. This new source of information can augment the accuracy of analyses and breaks new ground in terms of how such information can assist developers. We illustrate how the information we mine provides a refined notion of code ownership with respect to the one inferred by SCM system data. We demonstrate our approach on three case studies, including an industrial one. Ownership models suffer from the assumption that developers have a perfect memory. To account for their imperfect memory, we integrate into our ownership measurement a model of memory retention, to simulate the effect of memory loss over time. We evaluate the characteristics of this model for several strengths of memory.     

Semantic tagging and linking of software engineering social content

Social online communities and platforms play a significant role in the activities of software developers either as an integral part of the main activities or through complimentary knowledge and information sharing. As such techniques become more prevalent resulting in a wealth of shared information, the need to effectively organize and sift through the information becomes more important. Top-down approaches such as formal hierarchical directories have shown to lack scalability to be applicable to these circumstanes. Light-weight bottom-up techniques such as community tagging have shown promise for better organizing the available content. However, in more focused communities of practice, such as software engineering and development, community tagging can face some challenges such as tag explosion, locality of tags and interpretation differences, to name a few. To address these challenges, we propose a semantic tagging approach that benefits from the information available in Wikipedia to semantically ground the tagging process and provide a methodical approach for tagging social software engineering content. We have shown that our approach is able to provide high quality tags for social software engineering content that can be used not only for organizing such content but also for making meaningful and relevant content recommendation to the users both within a local community and also across multiple social online communities. We have empirically validated our approach through four main research questions. The results of our observations show that the proposed approach is quite effective in organizing social software engineering content and making relevant, helpful and novel content recommendations to software developers and users of social software engineering communities.     

Using Developer Activity Data to Enhance Awareness during Collaborative Software Development

Software development is a global activity unconstrained by the bounds of time and space. A major effect of this increasing scale and distribution is that the shared understanding that developers previously acquired by formal and informal face-to-face meetings is difficult to obtain. This paper proposes a shared awareness model that uses information gathered automatically from developer IDE interactions to make explicit orderings of tasks, artefacts and developers that are relevant to particular work contexts in collaborative, and potentially distributed, software development projects. The research findings suggest that such a model can be used to: identify entities (developers, tasks, artefacts) most associated with a particular work context in a software development project; identify relevance relationships amongst tasks, developers and artefacts e.g. which developers and artefacts are currently most relevant to a task or which developers have contributed to a task over time; and, can be used to identify potential bottlenecks in a project through a ‘social graph’ view. Furthermore, this awareness information is captured and provided as developers work in different locations and at different times.     

Pattern-based framework for modularized software development and evolution robustness

Context

Software development is now facing much more challenges than ever before due to the intrinsic high complexity and the increasing demands of the quick-service-ready paradigm.

Objective

As the developers are now called for more quality software systems from the industries, there is insufficient guidance from the methodologies and standards of software engineering that can provide assistance to the rapid development of qualified business software.

Method

In this work, we discuss the advantages of the pattern-based software development. We verify the benefits using a pattern-based software framework called OS2F, and a corresponding system design architecture that is intended for the rapid development of web applications.

Results

The objective of the framework/architecture is that, through software patterns, developers should be able to separate the work of system development from the business rules so as to reduce the problems caused by a developer’s lack of business experiences.

Conclusion

Through a suitable pattern-based software framework, the quality of the product can thus be enhanced, software development time and cost decreased, and software evolution robustness improved.     

Design and evaluation of the ModelHealth toolchain for continuity of care web services

Motivation: Systems interoperability is a key challenge in providing continuity of care to all patients. The challenge is addressed with information standards and new approaches to systems integration based on service-oriented architectures. Model-driven development promise utilities that are suitable for software service development in the healthcare domain, but development tools are still immature and their industry uptake is low. The knowledge about how model-driven development tools can become more useful to the healthcare software developers should be strengthened. Approach: This paper presents the ModelHealth toolchain that was created in four design/assess cycles, involving 28 students and 41 professional developers in the period 2007–2010. The toolchain provides design assistance for creating software services based on concepts from the CEN-13940 standard for continuity of care, which facilitates development of interoperable software services. Results: The CEN-13940 standard was successfully incorporated into the ModelHealth Toolchain assisting developers in creating software service design models that adhered to the standard. The developers expressed that improved understanding of the target system, documentation generation, and artifact traceability were essential utilities of the model-driven approach. Conclusion: The paper concludes healthcare domain knowledge can be successfully incorporated in a model-driven development toolchain, providing valuable input to the healthcare software service design process. A set of recommendations on how to incorporate domain specific concepts into model-driven development tools is provided. To our knowledge, no other scientific publications have reported from healthcare specific model-driven tool design and evaluations. Our recommendations extend and nuance existing knowledge on model-driven development tooling in general.     

Across disciplines: risk, design, method, process, and tools

In the search for solutions to make software development more predictable and controllable, one often looks for parallels in other disciplines such as architecture, bridge construction, and so on. The article looks at software development from the perspective of the electrical industry. Inspired by their management tradition, ATH techniek b.v. has learned to apply proven management techniques to software development. Simple and commonsense principles yield excellent results; for instance, developers reduced risk by estimating project effort using two different measures and by controlling execution. Comparing the software development processes with what goes on in the rest of the company or another application domain can be instructive     

Hipikat: a project memory for software development

Sociological and technical difficulties, such as a lack of informal encounters, can make it difficult for new members of noncollocated software development teams to learn from their more experienced colleagues. To address this situation, we have developed a tool, named Hipikat that provides developers with efficient and effective access to the group memory for a software development project that is implicitly formed by all of the artifacts produced during the development. This project memory is built automatically with little or no change to existing work practices. After describing the Hipikat tool, we present two studies investigating Hipikat's usefulness in software modification tasks. One study evaluated the usefulness of Hipikat's recommendations on a sample of 20 modification tasks performed on the Eclipse Java IDE during the development of release 2.1 of the Eclipse software. We describe the study, present quantitative measures of Hipikat's performance, and describe in detail three cases that illustrate a range of issues that we have identified in the results. In the other study, we evaluated whether software developers who are new to a project can benefit from the artifacts that Hipikat recommends from the project memory. We describe the study, present qualitative observations, and suggest implications of using project memory as a learning aid for project newcomers.     

软件众包开发者的能力价值率模型研究

为了更好地评价众包软件开发者的能力,分析了众包模式下软件众包开发的三个基本要素,即大众开发者、任务发布者、众包平台,提出了一种软件众包开发者能力价值率模型。该模型将软件众包任务从子任务、时间阶段、质量特性三个维度进行细分,首先评价众包原子单元,进而综合评估整个众包软件的质量。模型在评价过程中充分考虑了开发者的价值贡献因素,推演了开发者能力价值率的计算方法。验证实验表明软件众包开发者的综合能力价值率随着任务量的增加,其变化和能力大小关系趋于一致,所设计模型具有更好的稳定性,能够有效地评估软件众包开发者能力。     

软件知识库中数据挖掘技术研究

当前,软件系统的复杂度和规模也随着处理信息的增多而不断扩大,其开发和应用越来越困难,将软件工程项目的研究过程中产生的数据(软件知识库)抽取出有价值的信息可以帮助研发人员更好地实现软件,增强软件系统的功能和稳定性,是目前学术界研究的一个热点。     

The FreeBSD project: a replication case study of open source development

Case studies can help to validate claims that open source software development produces higher quality software at lower cost than traditional commercial development. One problem inherent in case studies are external validity - we do not know whether or not results from one case study apply to another development project. We gain or lose confidence in case study results when similar case studies are conducted on other projects. This case study of the FreeBSD project, a long-lived open source project, provides further understanding of open source development. The paper details a method for mining repositories and querying project participants to retrieve key process information. The FreeBSD development process is fairly well-defined with proscribed methods for determining developer responsibilities, dealing with enhancements and defects, and managing releases. Compared to the Apache project, FreeBSD uses 1) a smaller set of core developers - developers who control the code base - that implement a smaller percentage of the system, 2) a larger set of top developers to implement 80 percent of the system, and 3) a more well-defined testing process. FreeBSD and Apache have a similar ratio of core developers to people involved in adapting and debugging the system and people who report problems. Both systems have similar defect densities and the developers are also users in both systems.     

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.     

Software,regulation, and domain specificity

The growing pervasiveness of computer systems is bringing with it more societal reliance on those systems, which in turn is attracting the attention of various legal and political entities. This increasing attention will, one way or another, result in more regulation. This paper discusses regulation and its various forms, its effects on software development, and the software development tools and techniques that can be used to respond effectively to the demands of regulation. In particular, the maturing of software technology is leading to domain specific solutions that fit the needs of both software developers and regulators.     

基于ViewPoint的软件构架描述

软件构架作为系统开发的蓝图,已成为软件工程领域的热点。在软件开发实践中,许多项目更为关注的是软件构架的设计,而忽略了软件构架的描述。事实上软件构架的详细精确描述是成功开发软件的根本保证。文中以UML为构架描述语言,引用IEEE 1471标准中Viewpoint的概念,提出了基于3大Viewpoint的软件构架描述方法。基于Viewpoint的软件构架描述方法有助于开发人员在大型项目开发中从更高层次把握系统构架,从而保证软件开发过程的顺利进行。