- Research Article
- 10.1002/stvr.443
Editorial: Agility must be good for testing
- Sep 01, 2010
- Software Testing, Verification and Reliability
- Jeff Offutt
Editorial: Agility must be good for testing
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
Editorial: Agility must be good for testing
Editorial: Agility must be good for testing
Test-Driven Web Application Development in Java
Today, software availability as well as adaptability has a strong impact on application development. Together with the success of the Internet technology, it is often necessary to offer a web-based software solution. For Java development, J2EE builds a bridge from traditional towards web application development. Java Server Pages and Servlets allow the implementation of web sites with dynamic content. Anyway, it is still possible to apply well-tried programming paradigms, e.g. the Model-View-Controller (MVC) paradigm. With regard to software quality as well as adaptability, application development is affected more and more by advanced testing techniques. Especially unit testing provides a powerful technique to develop new functionality as well as to extend and reuse existing parts. This is also strengthened by the success of agile processes that force test-driven development. From there, application code grows up with unit tests from scratch on. For Java, JUnit has become the defacto standard unit test environment. Nevertheless, test-driven web application development requires broadening the unit test approach. Considering the special requirements of web application development, both the scope of the unit tests as well as the JUnit framework itself have to be extended to enable a test-driven development. In this paper, we present an approach to customize the unit test cycle as well as the JUnit framework towards a test-driven web application development.
Read morePutting Requirements and Quality at the Core of Global Service Delivery: Current Efforts and Future Plans at Pace University
Putting Requirements and Quality at the Core of Global Service Delivery: Current Efforts and Future Plans at Pace University
Read moreFrom Code to Quality: Exploring Test-Driven Development in Modern Software Engineering
Test-Driven Development (TDD) is a powerful methodology that bridges the gap between testing and development in software engineering. This approach prioritizes writing tests before writing the actual code, ensuring that each component meets its intended purpose from the outset. The process of TDD typically follows a simple cycle of writing a test, implementing the code, and refactoring, known as the "Red-Green-Refactor" loop. TDD offers several advantages, including enhanced code quality, reduced debugging time, and a smoother integration process, making it an essential practice for both developers and testers. By focusing on small, incremental code changes, TDD also encourages developers to write cleaner, more maintainable code. In addition, TDD fosters collaboration between developers and testers, as it requires early test creation and feedback integration. Despite some initial challenges, such as the learning curve and time investment, TDD has proven to increase overall productivity and product reliability. This article provides a comprehensive guide to understanding and implementing TDD, including its benefits, challenges, and real-world applications, to help teams adopt this best practice effectively. Keywords: Test-Driven Development, TDD methodology, Agile testing, Automated testing, Code quality, Red- Green-Refactor cycle, Unit testing, Continuous testing, Test-first approach, Refactoring code
Read moreSociomaterial bricolage: The creation of location-spanning work practices by global software developers
Sociomaterial bricolage: The creation of location-spanning work practices by global software developers
Sociomaterial Bricolage: The Creation of Location-Spanning Work Practices by Global Software Developers
Sociomaterial Bricolage: The Creation of Location-Spanning Work Practices by Global Software Developers
Beyond variegation: The territorialisation of states, communities and developers in large-scale developments in Johannesburg, Shanghai and London
Large-scale urban development projects are a significant format of urban expansion and renewal across the globe. As generators of governance innovation and indicators of the future city in each urban context, large-scale development projects have been interpreted within frameworks of ‘variegations’ of wider circulating processes, such as neoliberalisation or financialisation. However, such projects often entail significant state support and investment, are strongly linked to a wide variety of transnational investors and developers and are frequently highly contested in their local environments. Thus, each project comes to fruition in a distinctive regulatory context, often as an exception to the norm, and each emerges through complex interactions over a long period of time amongst an array of actors. We therefore seek to broaden the discussion from an analytical focus on variegated globalised processes to consider three large-scale urban development projects (in Shanghai, Johannesburg and London) as distinctive (transcalar) territorialisations. Using an innovative comparative approach, we outline the grounds for a systematic analytical conversation across mega-urban development projects in very different contexts. Initially, comparability rests on the shared features of large-scale developments – that they are multi-jurisdictional, involve long time scales and bring significant financing challenges. Comparing three development projects, we are able to interrogate, rather than take for granted, how a range of wider processes, circulating practices, transcalar actors and territorial regulatory formations composed specific urban outcomes in each case. Thinking across these diverse cases provides grounds for rebuilding understandings of urban development politics.
Read moreAdding Criteria-Based Tests to Test Driven Development
Test driven development (TDD) is the practice of writing unit tests before writing the source. TDD practitioners typically start with example-based unit tests to verify an understanding of the software's intended functionality and to drive software design decisions. Hence, the typical role of test cases in TDD leans more towards specifying and documenting expected behavior, and less towards detecting faults. Conversely, traditional criteria-based test coverage ignores functionality in favor of tests that thoroughly exercise the software. This paper examines whether it is possible to combine both approaches. Specifically, can additional criteria based tests improve the quality of TDD test suites without disrupting the TDD development process? This paper presents the results of an observational study that generated additional criteria-based tests as part of a TDD exercise. The criterion was mutation analysis and the additional tests were designed to kill mutants not killed by the TDD tests. The additional unit tests found several software faults and other deficiencies in the software. Subsequent interviews with the programmers indicated that they welcomed the additional tests, and that the additional tests did not inhibit their productivity.
Read moreUnit Tests and TDD
While both acceptance-test-driven development (ATDD) and test-driven development (TDD) are methodologies that advocate writing the tests before the code, ATDD (or BDD) is usually considered to lend itself better to bigger test scopes and to scenarios that describe how the users use the system, while TDD is considered to lend itself more specifically to unit tests, which uses the smallest test scope (of a single class or even a method), and therefore tests more technical details. For that reason, unit tests and TDD are considered practices that are done directly by the same developer that implements the code under test (CUT). While toward the end of this chapter we’ll question the distinction between TDD and ATDD, we first need to understand more about unit tests and TDD in general.
Read moreAffective reactions and test-driven development: Results from three experiments and a survey
Affective reactions and test-driven development: Results from three experiments and a survey
Translation of Activities in a Global Virtual Teams Software Development
. This study explores Global Virtual Software Teams’ development practices and try to demystify some of the misconceptions about global software development practices based on findings from the global virtual software teams’ experiment that was carried out at DePaul University from 2011 – 2018. The moments of translation from the perspective of actor-network theory (ANT) was employed in the data analysis, to examine how development approach was selected by the global virtual teams. One of the key findings from our research is that the success of a global software development project does not have a strong dependency on the development approach. While we agree that it is one of the key influencing factors, there are other equally strong factors for global virtual software team’s success.
Read moreOn the effectiveness of unit tests in test-driven development
Background: Writing unit tests is one of the primary activities in test-driven development. Yet, the existing reviews report few evidence supporting or refuting the effect of this development approach on test case quality. Lack of ability and skills of developers to produce sufficiently good test cases are also reported as limitations of applying test-driven development in industrial practice. Objective: We investigate the impact of test-driven development on the effectiveness of unit test cases compared to an incremental test last development in an industrial context. Method: We conducted an experiment in an industrial setting with 24 professionals. Professionals followed the two development approaches to implement the tasks. We measure unit test effectiveness in terms of mutation score. We also measure branch and method coverage of test suites to compare our results with the literature. Results: In terms of mutation score, we have found that the test cases written for a test-driven development task have a higher defect detection ability than test cases written for an incremental test-last development task. Subjects wrote test cases that cover more branches on a test-driven development task compared to the other task. However, test cases written for an incremental test-last development task cover more methods than those written for the second task. Conclusion: Our findings are different from previous studies conducted at academic settings. Professionals were able to perform more effective unit testing with test-driven development. Furthermore, we observe that the coverage measure preferred in academic studies reveal different aspects of a development approach. Our results need to be validated in larger industrial contexts.
Read moreCreation of a Framework and a Corresponding Tool Enabling the Test-Driven Development of Microservices
Microservice architectures have emerged as counter design to traditional monolithic applications. While monoliths are single executable applications, microservice architectures consist of several smaller units. Advantages of microservice architectures are their development speed, lower costs of change, and dynamic scaling ability. However, this pattern requires an adaptation of quality assurance measures. In this research article, test-driven development is investigated in context of microservices that are developed according to established practices. Based on the systems development research methodology, recommendable practices and testing strategies are examined with a translation of that knowledge into an extensive artifact, enabling test-driven microservice development on local systems. Five design principles could be identified, including focusing small services, domain-driven design, striving for low-complexity networks, avoiding cyclic dependencies, and aiming for high connectivity performance. Integration, component, and contract tests could be integrated for automatic execution, showing that test-driven development for microservices is feasible, although with room for improvements.
Read moreAn Evaluation Study of Architectural Design Decision Paradigms in Global Software Development
Global software development (GSD) is considered as the coordinated activities of software development that are geographically and temporally distributed. The management of architectural knowledge, specifically, architectural design decisions (ADDs), becomes important in GSD due to the geographical, temporal, and cultural challenges in global environments. Based on our previous work on ADD management in localized software development (LSD), we present five ADD paradigms used for GSD projects with different organizational structures. We also investigate the benefits and the challenges of the ADD paradigms by conducting an evaluation of the paradigms using extensive archived semi-structured interview data from industrial GSD projects. We aim to provide a fundamental framework for managing ADD documentation and evolution in GSD, as well as offer useful insights into managing architectural knowledge in a global setting.
Read moreEvaluating Success Factors of Software Project Management in Global Software Development
At present global software development (GSD) is gaining considerable attention in software industry. The management of global software projects presents substantial complexity owing to several inherent challenges of GSD. The project management practices used to execute in-house development projects are inadequate to address the unique challenges posed by global software projects, making their management a formidable task. Software organizations rely on traditional project management practices with the aim of managing global software projects, often resulting in impairments or failures. This paper explores the critical success factors (CSFs) in project management for global projects by developing a framework for effective project management within the context of GSD. The study focuses on identifying and prioritizing CSFs in software project management within a GSD setting utilizing Multi Criteria Decision Making (MCDM) analysis methods. Therefore, present research provides an extensive literature review of CSFs in software project management within GSD. Additionally, the research applies the combinatorial approach to assess the various dimensions and CSFs of software project management in GSD. The proposed approach aids in measuring and comparing the effect of several dimensions and CSFs of software project management in GSD. Five dimensions and twenty factors have been determined through literature review and further evaluated for prioritization using the combinatorial approach. The identified dimensions and factors will be valuable in devising strategies to effectively manage global software projects.
Read more