Test-Driven Development of Relational Databases

In test-first development, developers formulate and implement a detailed design iteratively, one test at a time. Test-driven development (also called test-driven design) combines TFD with refactoring, wherein developers make small changes (refactorings) to improve code design without changing the code's semantics. When developers decide to use TDD to implement a new feature, they must first ask whether the current design is the easiest possible design to enable the feature's addition. Implementing test-driven database design involves database refactoring, regression testing, and continuous integration. TDDD is an integrated part of the overall development process, not a standalone activity that data professionals perform in parallel with application TDD. Although from a technical view point, TDDD is relatively straightforward, we must overcome several challenges to its whole sale adoption throughout the IT community     

How to get mature global virtual teams: a framework to improve team process management in distributed software teams

Managing global software development teams is not an easy task because of the additional problems and complexities that have to be taken into account. This paper defines VTManager, a methodology that provides a set of efficient practices for global virtual team management in software development projects. These practices integrate software development techniques in global environments with others such as explicit practices for global virtual team management, definition of skills and abilities needed to work in these teams, availability of collaborative work environments and shared knowledge management practices. The results obtained and the lessons learned from implementing VTManager in a pilot project to develop software tools for collaborative work in rural environments are also presented. This project was carried out by geographically distributed teams involving people from seven countries with a high level of virtualness.     

An empirically-based characterization and quantification of information seeking through mailing lists during Open Source developers’ software evolution

ContextSeveral authors have proposed information seeking as an appropriate perspective for studying software evolution. Empirical evidence in this area suggests that substantial time delays can accrue, due to the unavailability of required information, particularly when this information must travel across geographically distributed sites.ObjectiveAs a first step in addressing the time delays that can occur in information seeking for distributed Open Source (OS) programmers during software evolution, this research characterizes the information seeking of OS developers through their mailing lists.MethodA longitudinal study that analyses 17 years of developer mailing list activity in total, over 6 different OS projects is performed, identifying the prevalent information types sought by developers, from a qualitative, grounded analysis of this data. Quantitative analysis of the number-of-responses and response time-lag is also performed.ResultsThe analysis shows that Open Source developers are particularly implementation centric and team focused in their use of mailing lists, mirroring similar findings that have been reported in the literature. However novel findings include the suggestion that OS developers often require support regarding the technology they use during development, that they refer to documentation fairly frequently and that they seek implementation-oriented specifics based on system design principles that they anticipate in advance. In addition, response analysis suggests a large variability in the response rates for different types of questions, and particularly that participants have difficulty ascertaining information on other developer’s activities.ConclusionThe findings provide insights for those interested in supporting the information needs of OS developer communities: They suggest that the tools and techniques developed in support of co-located developers should be largely mirrored for these communities: that they should be implementation centric, and directed at illustrating “how” the system achieves its functional goals and states. Likewise they should be directed at determining the reason for system bugs: a type of question frequently posed by OS developers but less frequently responded to.     

The effectiveness of test-driven development: an industrial case study

Test-driven development (TDD) is a software development practice, where test cases are incrementally written before implementing the production code. This paper presents the results of a multi-case study investigating the effectiveness of TDD within an industrial environment. Three comparable medium-sized projects were observed during their development cycle. Two projects were driven without TDD practice, while the third one introduced TDD into the development process. The effectiveness of TDD was expressed in terms of external code quality, productivity, and maintainability. Our results indicate that the TDD developers produced higher quality code that is easier to maintain, although we did observe a reduction in productivity.     

Integrating geographically distributed development teams through increased product awareness

More and more product development projects involve geographically distributed groups of developers. One major problem among the members of such groups is the long-term lack of awareness of the activities in remote sites. In this paper we discuss the importance of awareness in distributed product development projects. We argue that generic services are needed in development environments in order to provide continuous awareness of activities in remote sites. We introduce a product awareness model that focuses on a shared composite product and the propagation of awareness in it. We describe the design and implementation of this awareness model in the form of an awareness engine called Gossip.     

From Aristotle to Ringelmann: a large-scale analysis of team productivity and coordination in Open Source Software projects

Complex software development projects rely on the contribution of teams of developers, who are required to collaborate and coordinate their efforts. The productivity of such development teams, i.e., how their size is related to the produced output, is an important consideration for project and schedule management as well as for cost estimation. The majority of studies in empirical software engineering suggest that - due to coordination overhead - teams of collaborating developers become less productive as they grow in size. This phenomenon is commonly paraphrased as Brooks’ law of software project management, which states that “adding manpower to a software project makes it later”. Outside software engineering, the non-additive scaling of productivity in teams is often referred to as the Ringelmann effect, which is studied extensively in social psychology and organizational theory. Conversely, a recent study suggested that in Open Source Software (OSS) projects, the productivity of developers increases as the team grows in size. Attributing it to collective synergetic effects, this surprising finding was linked to the Aristotelian quote that “the whole is more than the sum of its parts”. Using a data set of 58 OSS projects with more than 580,000 commits contributed by more than 30,000 developers, in this article we provide a large-scale analysis of the relation between size and productivity of software development teams. Our findings confirm the negative relation between team size and productivity previously suggested by empirical software engineering research, thus providing quantitative evidence for the presence of a strong Ringelmann effect. Using fine-grained data on the association between developers and source code files, we investigate possible explanations for the observed relations between team size and productivity. In particular, we take a network perspective on developer-code associations in software development teams and show that the magnitude of the decrease in productivity is likely to be related to the growth dynamics of co-editing networks which can be interpreted as a first-order approximation of coordination requirements.     

Impediments to requirements engineering during global software development

Developing software when team members are located in widely distributed geographic locations poses many challenges for developers, particularly during the requirements engineering (RE) phase. Using a case study of a large software development project with users located in the UK and software developers from an international software house based in New Zealand, the paper argues that while global RE using electronic communication media may be desirable in achieving economy of resources, social and cultural aspects of RE need to be considered so that lasting relationships with clients may be formed, and RE activities achieved. The main impediments to the process of RE during global software development are communication resulting from differences in shared meanings and context associated with the following: distribution of the clients and the development team; distribution of the development team; cultural differences between the clients and the development team; and cultural differences among the development team.     

Modeling collaboration for large-scale software system integration by formal communication models

In the development of large software systems, several synchronization points have to be passed successfully in order to achieve high-end user acceptance of the final system. In particular, the integration of conceptual design entities has turned out to be the most crucial step in software development. At this point, an explicit representation of the organizational knowledge, namely how the integration can be performed, is required. The overall organization of the integration of design entities is a set of knowledge, action (including communication), and time. The knowledge part comprises the integration procedure itself as well as the design entities. Actions are performed by the members of the project team (project leaders, developers). Each integration step has to be performed synchronized, so that each member of the development team knows concurrently the status of the integration procedure. All other individual design activities are usually performed asynchronously. According to the need for an explicit representation of the organizational knowledge for large software system design, this paper attempts tounderstand the nature of large software system integration and formallydescribes the coordination of a dispersed set of software developers. The organizational knowledge is represented by processes that occur in an asynchronous development environment. The design knowledge is assigned to logical formulas that are processed as exchanged messages among developers. Hence, the activities for integration are based on the transmission of messages. Time-critical events, such as the integration of a particular design entity into the final conceptual design of the software system, have to become common knowledge concurrently for all developers. This organizational constraint has been formalized in the communication model. Not only can the proposed framework be adapted to organizational changes in a flexible way, it can also be applied to any specific development strategy for the integration of conceptual design entities. Thus, such kind of formal communication models may provide a sound basis for cooperative CASE (computer-aided software engineering) tools.This work has been sponsored by the Max Kade Foundation, New York.     

Test-driven development with mutation testing – an experimental study

Software Quality Journal - Test-driven development (TDD) is a popular design approach used by the developers with testing being the important software development driving factor. On the other hand,...     

Extracting communication structure of a development organization from a software repository

Researchers have found that communication cost is one of the major overheads affecting the overall cost of software development. Actually, there could be communication problems caused by cultural difference, language barrier, different time zone, and, etc. in geographically distributed software development. Thus, extracting potential communication structural information is very useful in understanding and optimizing the development organization. Analyzing the communication structure is also crucial in order to resolve cost issues. While this is already true for general development organizations, geographically distributed software development organizations are especially sensitive to these issues because they are forced to rely on costly mediums. Therefore, this paper suggests a way to extract the development organization from software repositories with respect to the temporal locality. The temporal locality is important for when the project is prolonged for a lengthy period of time. In order to evaluate these issues, we define two metrics which measure contribution of the individual developer and communication need between developers. We also provide a tool to extract a communication structure using these two metrics. The extracted communication structure is visualized to give insight into managers and developers. Finally, we provide statistical results of empirical research to prove the soundness of our approach. The result shows that our approach reflects the real-world relationship between developers well.     

大规模C＋＋软件系统测试驱动开发的设计与实践

介绍了在LINUX环境下采用测试驱动开发（Test-Driven Development,TDD）,对大规模C＋＋软件系统进行增量开发的方法。通过采用Google单元测试框架优化单元测试用例结构,提高单元测试的效率,采用新一代版本构建工具Scons优化复杂的代码依赖关系,采用分布式编译工具Distcc、编译器缓存工具C Cache优化版本构建时间,极大减少了软件开发人员在开发过程中进行TDD所必需的频繁本地构建的成本,为在大规模C＋＋历史遗留系统上,采用TDD进行增量开发,以及进行由此带来的小规模重构提供了有效保证。     

Engineers don't build [software development]

Most of us never approach a construction project with a software development methodology. However, construction projects exhibit much higher success rates than software development projects. The author identifies the “master-builder” approach taken by most software development projects where the developers assume the role of architect, engineer, builder, and inspector. Most large-scale construction projects abandoned the approach nearly 100 years ago. Why do we do it for large-scale software projects? Engineers design systems or buildings, and programmers or builders implement them. That approach yields greater success rates in terms of quality, time, and budget     

Understanding the functions of teleconferences for coordinating global software development projects

One of the dominant characteristics of contemporary software development is the global distribution of tasks, of developers, of information and of technologies. Undoubtedly, such distribution engenders new coordination challenges in the form of distance‐related interdependencies. One of the predominant processes of addressing these challenges is electronic meetings (or teleconferences). However, the functions of these meetings for coordination purposes are not yet understood. The distinctive conventions of teleconferences and their causal relationships that lead to optimal coordination of global software development (GSD) projects are also not yet understood. In this paper, the functions of teleconferences held by globally distributed software developers to coordinate their work in the face of global distribution of resources, cross‐site information interdependencies and continuously changing software requirements are analysed. The analysis is based on a qualitative study of how a subunit of 13 software developers, distributed across three sites in the USA and one in Republic of Ireland, used teleconferences to address its coordination challenges. The paper proffers a teleconference approach to GSD coordination by arguing that the functions of teleconferences manifest in software developers' multitasking; their ready access to all their information as additional benefits; flexibility in their communicative behaviours; and a reduction in their structure overload. This approach draws attention to these manifestations as distinctive conventions of the de‐structured meeting, which de‐structuring is occasioned by organic information processing needs in teleconferencing. This approach also explains why the combination of global distribution and teleconferences is a strategic opportunity for information processing for software process coordination.     

Traceability process for large OO projects

Object-oriented software development has become popular, but scaling it up for large projects has been a problem. With large OO projects, late integration problems are a particular concern. They can cause schedule slippage and other difficulties. I developed a process called Traceability for OO Quality Engineering, or TOOQE, to minimize such problems. TOOQE emphasizes traceability and the integration of development and testing to achieve quality and maintainability. TOOQE features an iterative design process that lets developers correct mistakes and learn more about the problem they are trying to solve as they go along. Each iteration includes requirements capture, analysis, design, coding, and testing. In other words, each is a mini-life cycle     

Developing applications using model-driven design environments

Historically, software development methodologies have focused more on improving tools for system development than on developing tools that assist with system composition and integration. Component-based middleware like Enterprise Java-Beans (EJB), Microsoft .NET, and the CORBA Component Model (CCM) have helped improve software reusability through component abstraction. However, as developers have adopted these commercial off-the-shelf technologies, a wide gap has emerged between the availability and sophistication of standard software development tools like compilers and debuggers, and the tools that developers use to compose, analyze, and test a complete system or system of systems. As a result, developers continue to accomplish system integration using ad hoc methods without the support of automated tools. Model-driven development is an emerging paradigm that solves numerous problems associated with the composition and integration of large-scale systems while leveraging advances in software development technologies such as component-based middleware. MDD elevates software development to a higher level of abstraction than is possible with third-generation programming languages.     

基于多维特征的开源项目个性化推荐方法

随着软件协同开发技术与社交网络的深度融合,社交化开发范式已成为当前软件创作与生产的重要方式。这一软件开发模型的灵活性与开放性,吸引了大规模的外围贡献者加入到开源社区中,形成了巨大的软件生产力。在开源社区中,这些分布广泛、规模巨大的外围贡献者主要以一种无组织的松散方式进行协同。他们需要花费大量的时间和精力,在海量的开源项目中寻找到自己真正感兴趣的项目并进行长期贡献。为了提高大规模群体协同的效率,本文提出一种基于多维特征的开源项目个性化推荐方法（即RepoLike）。该方法从开源项目自身流行度、关联项目技术相关度以及大众贡献者之间的社交关联度等三个维度度量开发者和开源项目之间的关联关系,并利用线性组合和Learning To Rank方法构建推荐模型,从而为开发者提供个性化的项目推荐服务。通过大规模的实证实验表明,RepoLike在推荐20个候选项目时的推荐命中率超过25%,能够有效地为开发人员提供有价值的推荐服务。     

开源软件开发者的演化研究

开源软件的开发主要依靠开发人员的自我管理和志愿贡献。在软件开发过程中,开发人员的组成、分工、能力等会发生经常性的改变,这些改变都会通过交互行为的变化反映出来。已有研究成果表明开源软件存在核心团队,他们主导项目的开发与实施,但对开发团队随时间而发生的结构变化的研究较少。通过观测软件项目生命周期中开发者总体的变化情况,研究了开发者网络与软件的协同演化机理,以GNU/Linux公共数据集为例,讨论了开源软件开发者数量、自愿度、开发者经验与项目的协同演化现象,并给出了演化的合理解释。     

Knowledge flow management for distributed team software development

Cognitive cooperation is often neglected in current team software development processes. This issue becomes more important than ever when team members are globally distributed. This paper presents a notion of knowledge flow and the related management mechanism for realizing an ordered knowledge sharing and cognitive cooperation in a geographically distributed team software development process. The knowledge flow can carry and accumulate knowledge when it goes through from one team member to another. The coordination between the knowledge flow process and the workflow process of a development team provides a new way to improve traditional team software development processes. A knowledge grid platform has been implemented to support the knowledge flow management across the Internet.     

An industry experiment on the effects of test-driven development on external quality and productivity

Existing empirical studies on test-driven development (TDD) report different conclusions about its effects on quality and productivity. Very few of those studies are experiments conducted with software professionals in industry. We aim to analyse the effects of TDD on the external quality of the work done and the productivity of developers in an industrial setting. We conducted an experiment with 24 professionals from three different sites of a software organization. We chose a repeated-measures design, and asked subjects to implement TDD and incremental test last development (ITLD) in two simple tasks and a realistic application close to real-life complexity. To analyse our findings, we applied a repeated-measures general linear model procedure and a linear mixed effects procedure. We did not observe a statistical difference between the quality of the work done by subjects in both treatments. We observed that the subjects are more productive when they implement TDD on a simple task compared to ITLD, but the productivity drops significantly when applying TDD to a complex brownfield task. So, the task complexity significantly obscured the effect of TDD. Further evidence is necessary to conclude whether TDD is better or worse than ITLD in terms of external quality and productivity in an industrial setting. We found that experimental factors such as selection of tasks could dominate the findings in TDD studies.     

Leader delegation in global software teams: occurrence and effects

Global teams are an important work structure in software development projects. Managing such complex global software projects presents many challenges to traditional leadership wisdom, in particular, how, why and when the leaders should delegate responsibility and authority. Delegation is considered an important leadership component to motivate and grow subordinates. Cultural differences, skill level disparity and potential competition between different software development sites creates a management context which is much different from where traditional leadership theories were developed. This study investigates leader delegation behaviors in global software teams and explores the reasons and impact of delegation strategies on global team performance. Semi-structured interviews and a survey was used to collect data from global software team managers and members from four countries of a Fortune 100 IT service company. The results of this study include in-depth analysis of hows and whys of leader delegation in global teams and a theoretical model for analyzing global team leader delegation occurrence and effects.