Test-driven Development Research Articles

Multi-Level Random Walk for Software Test Suite Reduction

Software testing is important and time-consuming. A test suite, i.e., a set of test cases, plays a key role in validating the expected program behavior. In modern test-driven development, a test suite pushes the development progress. Software evolves over time; its test suite is executed to detect whether a new code change adds bugs to the existing code. Executing all test cases after each code change is unnecessary and may be impossible due to the limited development cycle. On the one hand, multiple test cases may focus on an identical piece of code; then several test cases cannot detect extra bugs. On the other hand, even executing a test suite once in a large project takes around one hour [1]; frequent code changes require much time for conducting testing. For instance, in Hadoop, a framework of distributed computing, 2,847 version commits are accepted within one year from September 2014 with a peak of 135 commits in one week [2].

Teaching test-drive development using Dojo

Teaching Test-Driven Development (TDD) to the students is challenging. TDD is best learned when it is actually performed rather than read about. Especially when the students are novice to TDD, starting by writing a test first seems to be extremely hard, and proceeding with the small steps that the TDD cycle requires often demands explicit guidance. Coding Dojo is a dynamic and collaborative activity where people can practice programming, especially techniques related to agile methods. This paper discusses the two experiments conducted to find out how Coding Dojo methodology improves the code coverage of students programming and how it improves motivation in students to learn TDD.

Findings from a multi-method study on test-driven development

ContextTest-driven development (TDD) is an iterative software development practice where unit tests are defined before production code. A number of quantitative empirical investigations have been conducted about this practice. The results are contrasting and inconclusive. In addition, previous studies fail to analyze the values, beliefs, and assumptions that inform and shape TDD. ObjectiveWe present a study designed, and conducted to understand the values, beliefs, and assumptions about TDD. Participants were novice and professional software developers. MethodWe conducted an ethnographically-informed study with 14 novice software developers, i.e., graduate students in Computer Science at the University of Basilicata, and six professional software developers (with one to 10 years work experience). The participants worked on the implementation of a new feature for an existing software written in Java. We immersed ourselves in the context of our study. We collected qualitative information by means of audio recordings, contemporaneous field notes, and other kinds of artifacts. We collected quantitative data from the integrated development environment to support or refute the ethnography results. ResultsThe main insights of our study can be summarized as follows: (i) refactoring (one of the phases of TDD) is not performed as often as the process requires and it is considered less important than other phases, (ii) the most important phase is implementation, (iii) unit tests are almost never up-to-date, and (iv) participants first build in their mind a sort of model of the source code to be implemented and only then write test cases. The analysis of the quantitative data supported the following qualitative findings: (i), (iii), and (iv). ConclusionsDevelopers write quick-and-dirty production code to pass the tests, do not update their tests often, and ignore refactoring.

Bringing Architecture Thinking into Developers' Daily Activities

In software engineering there has traditionally been a distinction between high-level architecting and lower level implementation activities (e.g. coding and testing). Those who are developing and maintaining the software are often not engaged in early design activities. For example, software programmers tend to lack design and architecture skills and architects are often blamed for not knowing how to write good code and for not being involved in low-level implementation tasks. This results in software quality issues, software implementations that drifted from initial design, and incorrect or missing architectural decisions in the code. The continuous move towards reducing upfront architecture design efforts, and the popularity of practices such as test-driven development highlight the importance of enriching software implementation practices with new architecting notions, practices and tools. This was the topic of the First International Workshop on Bringing Architecture Design Thinking into Developers' Daily Activities. In this paper we summarize the workshop

State-of-the-Art Software Testing

Best practices for software testing include unit testing, test-driven development, using a test pyramid, test automation, continuous integration, test coverage analysis, A/B testing, and employing the appropriate metrics.

Effectiveness of Test Driven Development and Continuous Integration – A Case Study

In a case study where a Dutch small-to-medium enterprise (SME) implemented test-driven development and continuous integration, researchers observed that the SME discovered a higher number of defects compared to a baseline case study, and that there was an increase in the focus on quality and test applications.

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.

Test-driven approach in programming pedagogy

This paper describes the application of the test-driven paradigm to the learning of programming. It synthesizes experience with introducing the concept of test-driven development to computer scienc...

A Dissection of the Test-Driven Development Process: Does It Really Matter to Test-First or to Test-Last?

Background: Test-driven development (TDD) is a technique that repeats short coding cycles interleaved with testing. The developer first writes a unit test for the desired functionality, followed by the necessary production code, and refactors the code. Many empirical studies neglect unique process characteristics related to TDD iterative nature. Aim: We formulate four process characteristic: sequencing, granularity, uniformity, and refactoring effort. We investigate how these characteristics impact quality and productivity in TDD and related variations. Method: We analyzed 82 data points collected from 39 professionals, each capturing the process used while performing a specific development task. We built regression models to assess the impact of process characteristics on quality and productivity. Quality was measured by functional correctness. Result: Quality and productivity improvements were primarily positively associated with the granularity and uniformity. Sequencing, the order in which test and production code are written, had no important influence. Refactoring effort was negatively associated with both outcomes. We explain the unexpected negative correlation with quality by possible prevalence of mixed refactoring. Conclusion: The claimed benefits of TDD may not be due to its distinctive test-first dynamic, but rather due to the fact that TDD-like processes encourage fine-grained, steady steps that improve focus and flow.

The Unholy Trinity of Software Development

Questions like this bring to mind the fact that source code, documentation, and testing are the unholy trinity of software development, although many organizations like to see them as separate entities. It is interesting that while many groups pay lip service to "test-driven development," they do not include documentation in TDD.

GRNsight: a web application and service for visualizing models of small- to medium-scale gene regulatory networks

GRNsight is a web application and service for visualizing models of gene regulatory networks (GRNs). A gene regulatory network (GRN) consists of genes, transcription factors, and the regulatory connections between them which govern the level of expression of mRNA and protein from genes. The original motivation came from our efforts to perform parameter estimation and forward simulation of the dynamics of a differential equations model of a small GRN with 21 nodes and 31 edges. We wanted a quick and easy way to visualize the weight parameters from the model which represent the direction and magnitude of the influence of a transcription factor on its target gene, so we created GRNsight. GRNsight automatically lays out either an unweighted or weighted network graph based on an Excel spreadsheet containing an adjacency matrix where regulators are named in the columns and target genes in the rows, a Simple Interaction Format (SIF) text file, or a GraphML XML file. When a user uploads an input file specifying an unweighted network, GRNsight automatically lays out the graph using black lines and pointed arrowheads. For a weighted network, GRNsight uses pointed and blunt arrowheads, and colors the edges and adjusts their thicknesses based on the sign (positive for activation or negative for repression) and magnitude of the weight parameter. GRNsight is written in JavaScript, with diagrams facilitated by D3.js, a data visualization library. Node.js and the Express framework handle server-side functions. GRNsight’s diagrams are based on D3.js’s force graph layout algorithm, which was then extensively customized to support the specific needs of GRNs. Nodes are rectangular and support gene labels of up to 12 characters. The edges are arcs, which become straight lines when the nodes are close together. Self-regulatory edges are indicated by a loop. When a user mouses over an edge, the numerical value of the weight parameter is displayed. Visualizations can be modified by sliders that adjust the force graph layout parameters and through manual node dragging. GRNsight is best-suited for visualizing networks of fewer than 35 nodes and 70 edges, although it accepts networks of up to 75 nodes or 150 edges. GRNsight has general applicability for displaying any small, unweighted or weighted network with directed edges for systems biology or other application domains. GRNsight serves as an example of following and teaching best practices for scientific computing and complying with FAIR principles, using an open and test-driven development model with rigorous documentation of requirements and issues on GitHub. An exhaustive unit testing framework using Mocha and the Chai assertion library consists of around 160 automated unit tests that examine nearly 530 test files to ensure that the program is running as expected. The GRNsight application (http://dondi.github.io/GRNsight/) and code (https://github.com/dondi/GRNsight) are available under the open source BSD license.

Unit testing, model validation, and biological simulation.

The growth of the software industry has gone hand in hand with the developmentof tools and cultural practices for ensuring the reliability of complex piecesof software. These tools and practices are now acknowledged to be essential tothe management of modern software. As computational models and methods havebecome increasingly common in the biological sciences, it is important to examinehow these practices can accelerate biological software development and improveresearch quality. In this article, we give a focused case study of our experiencewith the practices of unit testing and test-driven development in OpenWorm, anopen-science project aimed at modeling Caenorhabditis elegans. We identify anddiscuss the challenges of incorporating test-driven development into a heterogeneous,data-driven project, as well as the role of model validation tests, a categoryof tests unique to software which expresses scientific models.

The impacts of agile and lean practices on project constraints: A tertiary study

The growing interest in Agile and Lean software development is reflected in the increasing number of secondary studies on the benefits and limitations of Agile and Lean processes and practices. The aim of this tertiary study is to consolidate empirical evidence regarding Agile and Lean practices and their respective impacts on project constraints as defined in the Project Management Body of Knowledge (PMBOK): scope, quality, schedule, budget, resources, communication, and risk. In this tertiary study, 13 secondary studies were included for detailed analysis. Given the heterogeneity of the data, we were unable to perform a rigorous synthesis. Instead, we mapped the identified Agile and Lean practices, and their impacts on the project constraints described in PMBOK. From 13 secondary studies, we identified 13 Agile and Lean practices. Test-Driven Development (TDD) is studied in ten secondary studies, meanwhile other practices are studied in only one or two secondary studies. This tertiary study provides a consolidated view of the impacts of Agile and Lean practices. The result of this tertiary study indicates that TDD has a positive impact on external quality. However, due to insufficient data or contradictory results, we were unable to make inferences on other Agile and Lean practices. Implications for research and practice are further discussed in the paper.

Development of a Wearable Cardiac Monitoring System for Behavioral Neurocardiac Training: A Usability Study.

BackgroundElevated blood pressure is one of the main risk factors for death globally. Behavioral neurocardiac training (BNT) is a complementary approach to blood pressure and stress management that is intended to exercise the autonomic reflexes, improve stress recovery, and lower blood pressure. BNT involves cognitive-behavioral therapy with a paced breathing technique and heart rate variability biofeedback. BNT is limited to in-clinic delivery and faces an accessibility barrier because of the need for clinical oversight and the use of complex monitoring tools.ObjectiveThe objective of this project was to design, develop, and evaluate a wearable electrocardiographic (ECG) sensor system for the delivery of BNT in a home setting.MethodsThe wearable sensor system, Beat, consists of an ECG sensor and a mobile app. It was developed iteratively using the principles of test-driven Agile development and user-centered design. A usability study was conducted at Toronto General Hospital to evaluate feasibility and user experience and identify areas of improvement.ResultsThe Beatsensor was designed as a modular patch to be worn on the user’s chest and uses standard ECG electrodes. It streams a single-lead ECG wirelessly to a mobile phone using Bluetooth Low Energy. The use of small, low-power electronics, a low device profile, and a tapered enclosure allowed for a device that can be unobtrusively worn under clothing. The sensor was designed to operate with a mobile app that guides users through the BNT exercises to train them to a slow-paced breathing technique for stress recovery. The BNT app uses the ECG captured by the sensor to provide heart rate variability biofeedback in the form of a real-time heart rate waveform to complement and reinforce the impact of the training. Usability testing (n=6) indicated that the overall response to the design and user experience of the system was perceived positively. All participants indicated that the system had a positive effect on stress management and that they would use it at home. Areas of improvement were identified, which focused primarily on the delivery of training and education on BNT through the app.ConclusionsThe outcome of this project was a wearable sensor system to deliver BNT at home. The system has the potential to offer a complementary approach to blood pressure and stress management at home and reduce current accessibility barriers.

Test-driven simulation modelling: A case study using agent-based maritime search-operation simulation

Model verification and validation (V&V) is one of the most important activities in simulation modelling. Model validation is especially challenging for Agent-Based Simulation (ABS). Techniques that can help to improve V&V in simulation modelling are needed. This paper proposes a V&V technique called Test-Driven Simulation Modelling (TDSM) which applies techniques from Test-Driven Development in software engineering to simulation modelling. The main principle in TDSM is that a unit test for a simulation model has to be specified before the simulation model is implemented. Hence, TDSM explicitly embeds V&V in simulation modelling. We use a case study in maritime search operations to demonstrate how TDSM can be used in practice. Maritime search operations (and search operations in general) are one of the classic applications of Operational Research (OR). Hence, we can use analytical models from the vast search theory literature for unit tests in TDSM. The results show that TDSM is a useful technique in the verification and validation of simulation models, especially ABS models. This paper also shows that ABS can offer an alternative modelling approach in the analysis of maritime search operations.

Structural Characterization of Humanized Nanobodies with Neutralizing Activity against the Bordetella pertussis CyaA-Hemolysin: Implications for a Potential Epitope of Toxin-Protective Antigen.

Previously, the 126-kDa CyaA-hemolysin (CyaA-Hly) fragment cloned from Bordetella pertussis—the causative agent of whooping cough—and functionally expressed in Escherichia coli was revealed as a key determinant for CyaA-mediated hemolysis against target erythrocytes. Here, phagemid-transfected E. coli clones producing nanobodies capable of binding to CyaA-Hly were selected from a humanized-camel VH/VHH phage-display library. Subsequently verified for binding activities by indirect ELISA and Western blotting, four CyaA-Hly-specific nanobodies were obtained and designated according to the presence/absence of VHH-hallmark amino acids as VHH2, VH5, VH18 and VHH37. In vitro neutralization assay revealed that all four ~17-kDa His-tagged VH/VHH nanobodies, in particular VHH37, which were over-expressed as inclusions and successfully unfolded-refolded, were able to effectively inhibit CyaA-Hly-mediated hemolysis. Phage-mimotope searching revealed that only peptides with sequence homologous to Linker 1 connecting Blocks I and II within the CyaA-RTX subdomain were able to bind to these four CyaA-Hly-specific nanobodies. Structural analysis of VHH37 via homology modeling and intermolecular docking confirmed that this humanized nanobody directly interacts with CyaA-RTX/Linker 1 through multiple hydrogen and ionic bonds. Altogether, our present data demonstrate that CyaA-RTX/Linker 1 could serve as a potential epitope of CyaA-protective antigen that may be useful for development of peptide-based pertussis vaccines. Additionally, such toxin-specific nanobodies have a potential for test-driven development of a ready-to-use therapeutic in passive immunization for mitigation of disease severity.

The effects of test driven development on internal quality, external quality and productivity: A systematic review

Context: Test Driven Development (TDD) is an agile practice that has gained popularity when it was defined as a fundamental part in eXtreme Programming (XP).Objective: This study analyzed the conclusions of previously published articles on the effects of TDD on internal and external software quality and productivity, comparing TDD with Test Last Development (TLD).Method: In this study, a systematic literature review has been conducted considering articles published between 1999 and 2014.Results: In about 57% of the analyzed studies, the results were validated through experiments and in 32% of them, validation was performed through a case study. The results of this analysis show that 76% of the studies have identified a significant increase in internal software quality while 88% of the studies identified a meaningful increase in external software quality. There was an increase in productivity in the academic environment, while in the industrial scenario there was a decrease in productivity. Overall, about 44% of the studies indicated lower productivity when using TDD compared to TLD.Conclusion: According to our findings, TDD yields more benefits than TLD for internal and external software quality, but it results in lower developer productivity than TLD.

Proposed Bilingual Model for Right to Left Language Applications

Using right to left languages (RLL) in software programming requires switching the direction of many components in the interface. Preserving the original interface layout and only changing the language may result in different semantics or interpretations of the content. However, this aspect is often dismissing in the field. This research, therefore, proposes a Bilingual Model (BL) to check and correct the directions in social media applications. Moreover, test-driven development (TDD) For RLL, such as Arabic, is considered in the testing methodologies. Similarly, the bilingual analysis has to follow both the TDD and BL models.

Collaboration Tools of the Agile Methodology Impact on the OS Project Evaluation

Agile development methodologies and open source software development process(OSSDP) has repeatedly called for common frequent releases and short development cycle. TDD(Test Driven Development) and refactoring (Refactoring) represented by the characteristics of Agile Techniques, and frequent communication represented by the characteristic of Agile methodology. If you apply the three factors in OSSDP will increase the satisfaction of the users and then participating in the OS project maturity also will increase. Received (September 03 2015), Review Result(September 21, 2015) Accepted(October 05, 2015), Published(December 31, 2015) 156-032 Dept. SW engeneering, Graduated Soongsil University, Sangdo-Dong, Dongjak-gu, Seoul, Korea email: hyojung.sohn@gmail.com 156-032 Dept. SW engeneering, Graduated Soongsil University, Sangdo-Dong, Dongjak-gu, Seoul, Korea email:marse101@naver.com 156-032 Dept. SW engeneering, Graduated Soongsil University, Sangdo-Dong, Dongjak-gu, Seoul, Korea email: feeling127@naver.com (Corresponding Author) 156-032 Dept. SW engeneering, Graduated Soongsil University, Sangdo-Dong, Dongjak-gu, Seoul, Korea email: kjb123@ssu.ac.kr Collaboration tools of the Agile methodology impact on the OS project evaluation Copyright c 2015 HSST 10 We established this research model. OS projects are geographically dispersed users, but utilizes several tools to communicate online degree in communication is bi-directional emphasis in Agile methodologies that reflect the characteristics of Web 2.0 tools than the traditional one-way communication, openness, communication reported to be satisfied by using the available tools, existing tools and improved tools to investigate the influence on user satisfaction. In this paper eoteumyeo to focus on communication elements of the three factors, further research, we want to make through the final research model studies and the results for each TDD and refactoring.

A Study on the Influence of Use of Web 2.0 Collaboration Tool Reflecting Agile Practice on the Evaluation of OS Project

For the agile development methodology that repeats the frequent releases and the short development periods, there are some value practices that we have to keep. Among them, three typical practices were selected: use of Web 2.0 collaboration tool, adoption of the test driven development (TDD) and refactoring. The agile practice that forces the communication between team members was defined with the use of Web 2.0 collaboration tool. When this is applied to the development method of open-source projects which are dispersed geographically, temporally and culturally, it is expected to raise the satisfaction of OS project users and to contribute the maturity of community. It was applied to the study models that were drawn out from the precedent studies. Today, OS project users are adopting diverse tools for the online communication. But the degree of communication that is emphasized in the agile methodology can be satisfied only with the use of two-way, open and communicable tools reflecting the characteristics of Web 2.0 rather than with the conventional one-way information transmitting tool. In this situation, it was examined how the conventional and the improved tools have influence on the users’ satisfaction. This paper is focusing on the communication factor among 3 factors.