Test-Driven Development in Large Projects

Test-driven development (TDD) is a key practice for agile developers because it involves writing test cases ahead of the code, which can improve design. The TDD process works well for projects in which a collocated team develops a small to medium system, but it can be challenging for large systems, especially those involving geographically distributed teams. The main obstacle is the degree of integration: when the team must integrate many individual classes developed at distributed sites, the coordination and communication grows exponentially with the number of individual developers and sites. This does not mean that TDD is ineffective for large-scale geographically distributed projects, but developers must take care to account for its focus on unit testing and its failure to rigorously address communications issues during system and integration testing. In this article, suggestions to scale up TDD are presented with two large-scale global software development projects at a major corporation and a recent meeting to exchange global software development best practices with a Fortune 500 company     

Prediction approach of software fault-proneness based on hybrid artificial neural network and quantum particle swarm optimization

The identification of a module's fault-proneness is very important for minimizing cost and improving the effectiveness of the software development process. How to obtain the correlation between software metrics and module's fault-proneness has been the focus of much research. This paper presents the application of hybrid artificial neural network (ANN) and Quantum Particle Swarm Optimization (QPSO) in software fault-proneness prediction. ANN is used for classifying software modules into fault-proneness or non fault-proneness categories, and QPSO is applied for reducing dimensionality. The experiment results show that the proposed prediction approach can establish the correlation between software metrics and modules’ fault-proneness, and is very simple because its implementation requires neither extra cost nor expert's knowledge. Proposed prediction approach can provide the potential software modules with fault-proneness to software developers, so developers only need to focus on these software modules, which may minimize effort and cost of software maintenance.     

An empirical approach to evaluating dependency locality in hierarchically structured software systems

In software development, especially component-based software development, dependency locality states that relevant software components should be at shorter distances than irrelevant components. This principle is used together with modularity and hierarchy to guide the design of large-scale complex software systems. In previous work, dependency locality and its correlation with design quality were studied by statically measuring the interactions between software components. This paper presents an empirical approach to evaluating the hierarchical structure of software systems through mining their revision history. Two metrics, spatial distance and temporal distance, are adapted to measure the dependencies between software components. The correlation of spatial distance and temporal distance between software components represents a factor that influences system design quality. More specially, a well designed system hierarchy should have a significant positive correlation while a non-significant positive correlation or a negative correlation would signify design flaws. In an application of this approach, we use Mantel test to study the dependency locality of six software systems from Apache projects.     

From stand-alone programs towards grid-aware services and components: a case study in agricultural modelling with interpolated climate data

We identify three key issues to be taken into account when designing the next generation of software environments for agricultural modelling. There is a burgeoning need to support collaborative research in a search for answers to big research questions, to integrate the work of data providers and model developers and to provide more generic systems. We describe the concepts of software design of a framework, designed with these points in mind, which facilitates the integration of point-based agricultural models with methods to interpolate climate data. Our approach allows the inter-working of model and interpolation through Fortran functions that are invoked from a central framework. We advocate that the framework code remains open to collaborators, such that it may be adapted to different classes of application, whilst recognising that some module developers need to retain their control on individual elements of the software. The rationale presented within the paper continues a major move away from the stand-alone programs that still dominate agricultural models and interpolation methods.Secondly, the paper considers how these approaches are extendable to exploit opportunities in the emerging Web Service and Grid context. The emerging technology of the Grid allows geographically distributed resources in hardware, software, data and network to be co-ordinated to meet the needs of “virtual organisations.” We explore how the modularity of our existing code can be exploited in the Grid environment, whilst noting the pre-requisite of a co-operative culture in which both software developers and data providers seek to deliver services to the widest possible community of users.     

Effective communication,collaboration, and coordination in eXtreme Programming: Human‐centric perspective in a small organization

Effective communication, collaboration, and coordination are important contributing factors in achieving success in agile software development projects. The significance of the workplace environment and tools are immense in effective communication, collaboration, and coordination among people performing software development. In this article, we study how the workplace environment and the effective use of tools like whiteboards, status boards, and so forth for exchanging information improved communication, collaboration, and coordination without compromising the ability to do individual work by developers in a small‐scale software development organization. Based on experience and an extensive literature review of communication, collaboration, coordination, and the significance of these in the workplace environment, a survey questionnaire was developed to collect data and observe the effect of these in a small software development organization. Our study indicated appropriate workspace environment has a positive effect on communication, collaboration, and coordination in small organizations developing software using eXtreme Programming (XP). © 2009 Wiley Periodicals, Inc.     

Effectiveness of caching in a distributed digital library system

Today independent publishers are offering digital libraries with fulltext archives. In an attempt to provide a single user-interface to a large set of archives, the studied Article-Database-Service offers a consolidated interface to a geographically distributed set of archives. While this approach offers a tremendous functional advantage to a user, the fulltext download delays caused by the network and queuing in servers make the user-perceived interactive performance poor.This paper studies how effective caching of articles at the client level can be achieved as well as at intermediate points as manifested by gateways that implement the interfaces to the many fulltext archives. A central research question in this approach is: What is the nature of locality in the user access stream to such a digital library? Based on access logs that drive the simulations, it is shown that client-side caching can result in a 20% hit rate. Even at the gateway level temporal locality is observable, but published replacement algorithms are unable to exploit this temporal locality. Additionally, spatial locality can be exploited by considering loading into cache all articles in an issue, volume, or journal, if a single article is accessed. But our experiments showed that improvement introduced a lot of overhead. Finally, it is shown that the reason for this cache behavior is the long time distance between re-accesses, which makes caching quite unfeasible.     

Efficient selection strategies towards processor reordering techniques for improving data locality in heterogeneous clusters

Grid architecture integrates geographically distributed nodes to manage and provide resources to execute scientific applications. For data locality, applications with different computational phases require data redistribution for realignment. The tradeoff between high efficiency computation and communication cost of data redistribution accompanies. This paper introduces a research model and two methods to derive new lists of processor logical id according to the characteristics of heterogeneous network. Both methods provide choices of more low-cost communication schedules in grid. The simulations show both proposed methods yield outstanding performance in grid.     

Software engineering metrics for COTS-based systems

The paradigm shift to commercial off-the-shelf components appears inevitable, necessitating drastic changes to current software development and business practices. Quality and risk concerns currently limit the application of COTS based system design to noncritical applications. New approaches to quality and risk management will be needed to handle the growth of CBSs. Our metrics based approach and software engineering metrics can aid developers and managers in analyzing the return on investment in quality improvement initiatives for CBSs. These metrics also facilitate the modeling of cost and quality, although we need more complex models to capture the intricate relationships between cost and quality metrics in a CBS     

Prototyping: some new results

This research describes a survey of experienced software development practitioners in large organizations for their perceptions of the relative merits of the prototyping and waterfall approaches. Some results of earlier research are confirmed but a number of new insights are obtained. Prototyping is used by developers who are mainly concerned with early life cycle issues; improved communication with users, increased flexibility of the design produced and for early discovery of problems. Non-prototypers prefer to use a waterfall approach because they are more concerned with later life cycle issues—level of control provided, good communication with IS personnel, and the robustness and maintainability of the systems produced.     

DCTracVis: a system retrieving and visualizing traceability links between source code and documentation

It is well recognized that traceability links between software artifacts provide crucial support in comprehension, efficient development, and effective management of a software system. However, automated traceability systems to date have been faced with two major open research challenges: how to extract traceability links with both high precision and high recall, and how to efficiently visualize links for complex systems because of scalability and visual clutter issues. To overcome the two challenges, we designed and developed a traceability system, DCTracVis. This system employs an approach that combines three supporting techniques, regular expressions, key phrases, and clustering, with information retrieval (IR) models to improve the performance of automated traceability recovery between documents and source code. This combination approach takes advantage of the strengths of the three techniques to ameliorate limitations of IR models. Our experimental results show that our approach improves the performance of IR models, increases the precision of retrieved links, and recovers more correct links than IR alone. After having retrieved high-quality traceability links, DCTracVis then utilizes a new approach that combines treemap and hierarchical tree techniques to reduce visual clutter and to allow the visualization of the global structure of traces and a detailed overview of each trace, while still being highly scalable and interactive. Usability evaluation results show that our approach can effectively and efficiently help software developers comprehend, browse, and maintain large numbers of links.     

Enhancing collaborative synchronous UML modelling with fine-grained versioning of software artefacts

Software development teams are composed of people with different knowledge and skills, who contribute to a project from often widely dispersed locations. Software development in geographically distributed environments creates software engineering challenges due to the interaction among members of distributed teams and the management of consistency and concurrency among project artefacts. In this paper, we propose Synchronous collaborative modelling Tool Enhanced with VErsioning management (STEVE) a collaborative tool supporting distributed Unified Modelling Language (UML) modelling of software systems. The tool provides a communication infrastructure enabling the concurrent editing of the same UML diagram at the same time by distributed developers. Complex UML diagrams are decomposed and managed in a fine-grained hierarchy of sub-artefacts, thus providing change and configuration management functionalities for both the diagram and the graphical objects. Thus, software predefined diagram components can be consistently reused and shared across different diagrams of a given project.     

Groupware development support with technology patterns

Groupware development support should educate developers on how to design groupware applications and foster the reuse of proven solutions. Additionally, it should foster communication between developers and end-users, since they need a common language and understanding of the problem space. Groupware frameworks provide solutions for the development of groupware applications by means of building blocks. They have become a prominent means to support developers, but from our experience frameworks have properties that complicate their usage and do not sufficiently support groupware developers. We argue for a pattern approach to support the technical aspects of groupware development. Patterns describe solutions to recurring issues in groupware development. They serve as educational and communicative vehicle for reaching the above goals. In this article, we provide a pattern language focusing on technical issues during groupware development. Experiences when using the language in an educational setting and a product development setting have shown that the patterns are a supportive means for the proposed goals.     

Locality-aware parallel block-sparse matrix-matrix multiplication using the Chunks and Tasks programming model

We present a method for parallel block-sparse matrix-matrix multiplication on distributed memory clusters. By using a quadtree matrix representation, data locality is exploited without prior information about the matrix sparsity pattern. A distributed quadtree matrix representation is straightforward to implement due to our recent development of the Chunks and Tasks programming model [Parallel Comput. 40, 328 (2014)]. The quadtree representation combined with the Chunks and Tasks model leads to favorable weak and strong scaling of the communication cost with the number of processes, as shown both theoretically and in numerical experiments.Matrices are represented by sparse quadtrees of chunk objects. The leaves in the hierarchy are block-sparse submatrices. Sparsity is dynamically detected by the matrix library and may occur at any level in the hierarchy and/or within the submatrix leaves. In case graphics processing units (GPUs) are available, both CPUs and GPUs are used for leaf-level multiplication work, thus making use of the full computing capacity of each node.The performance is evaluated for matrices with different sparsity structures, including examples from electronic structure calculations. Compared to methods that do not exploit data locality, our locality-aware approach reduces communication significantly, achieving essentially constant communication per node in weak scaling tests.     

A Practical Approach for Quality-Driven Inspections

Software inspection is a rigorous process for validating software work products that's both efficient and cost effective. However, this process presents challenges that might keep software developers from continuing to implement inspections. From our experience, major reasons for this are poor or missing customization of inspections for given context characteristics and insufficient stakeholder involvement. The TAQtIC (Tailoring Approach for Quality-Driven Inspections) inspection approach lets organizations implement inspections in a sustainable way in a given organizational context. Practitioners can use TAQtIC's underlying concepts to customize inspections for their environment. Experiences from projects using this approach demonstrate how organizations can tailor inspections of their software products     

Multi-metaphor method: organizational metaphors in information systems development

Abstract.  Conventional methods have been criticized for their positivist philosophy and for either ignoring the organizational context of information systems development (ISD) or using only a simplistic, machine-based conceptual model of organizations. We have developed an approach to enable systems developers to use a richer view of organizations and a more interpretive approach. Multi-Metaphor Method (MMM) supports developers via a range of metaphors as cognitive structuring devices to understand an organization so that developers can learn to move between different ways of 'reading' the social context in which ISD occurs. We explain the rationale and theoretical underpinnings of MMM and then discuss our action research to investigate the viability and relevance of MMM during ISD practice. We show how the developers' use of organizational metaphors via MMM did not just enable rich conceptualizations of the client organizations but also influenced the ISD process and final product. We review the learning outcomes and discuss the implications for systems development practice of our research.     

On the Need for Mixed Media in Distributed Requirements Negotiations

Achieving agreement with respect to software requirements is a collaborative process that traditionally relies on same-time, same-place interactions. As the trend toward geographically distributed software development continues, colocated meetings are becoming increasingly problematic. Our research investigates the impact of computer-mediated communication on the performance of distributed client/developer teams involved in the collaborative development of a requirements specification. Drawing on media-selection theories, we posit that a combination of lean and rich media is needed for an effective process of requirements negotiations when stakeholders are geographically dispersed. In this paper, we present an empirical study that investigates the performance of six educational global project teams involved in a negotiation process using both asynchronous text-based and synchronous videoconferencing-based communication modes. The findings indicate that requirement negotiations were more effective when the groups conducted asynchronous structured discussions of requirement issues prior to the synchronous negotiation meeting. Asynchronous discussions were useful in resolving issues related to uncertainty in requirements, thus allowing synchronous negotiations to focus more on removing ambiguities in the requirements.     

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.     

Explaining software developer acceptance of methodologies: a comparison of five theoretical models

Many organizations attempt to deploy methodologies intended to improve software development processes. However, resistance by individual software developers against using such methodologies often obstructs their successful deployment. To better explain why individual developers accept or resist methodologies, five theoretical models of individual intentions to accept information technology tools were examined. In a field study of 128 developers in a large organization that implemented a methodology, each model explained significant variance in developers' intentions to use the methodology. Similar to findings from the tool adoption context, we found that, if a methodology is not regarded as useful by developers, its prospects for successful deployment may be severely undermined. In contrast to the typical pattern of findings in a tool context, however, we found that methodology adoption intentions are driven by: 1) the presence of an organizational mandate to use the methodology, 2) the compatibility of the methodology with how developers perform their work, and 3) the opinions of developers' coworkers and supervisors toward using the methodology. Collectively, these results provide surprising new insights into why software developers accept or resist methodologies and suggest what software engineering managers might do to overcome developer resistance.     

Developing applications in large scale,dynamic fog computing: A case study

In recent years, fog computing has emerged as a new distributed system model for a large class of applications that are data-intensive or delay-sensitive. By exploiting widely distributed computing infrastructure that is located closer to the network edge, communication cost and service response time can be significantly reduced. However, developing this class of applications is not straightforward and requires addressing three key challenges, ie, supporting the dynamic nature of the edge network, managing the context-dependent characteristics of application logic, and dealing with the large scale of the system. In this paper, we present a case study in building fog computing applications using our open source platform Distributed Node-RED (DNR). In particular, we show how applications can be decomposed and deployed to a geographically distributed infrastructure using DNR, and how existing software components can be adapted and reused to participate in fog applications. We present a lab-based implementation of a fog application built using DNR that addresses the first two of the issues highlighted earlier. To validate that our approach also deals with large scale, we augment our live trial with a large scale simulation of the application model, conducted in Omnet++, which shows the scalability of the model and how it supports the dynamic nature of fog applications.