Selecting Software Test Data Using Data Flow Information
IEEE Transactions on Software Engineering
Extreme programming explained: embrace change
Extreme programming explained: embrace change
Building Knowledge through Families of Experiments
IEEE Transactions on Software Engineering
Experimentation in software engineering: an introduction
Experimentation in software engineering: an introduction
Software reliability and dependability: a roadmap
Proceedings of the Conference on The Future of Software Engineering
Testing object-oriented systems: models, patterns, and tools
Testing object-oriented systems: models, patterns, and tools
Pair Programming Illuminated
Agile Software Development with Scrum
Agile Software Development with Scrum
Test Driven Development: By Example
Test Driven Development: By Example
A Practical Guide to Feature-Driven Development
A Practical Guide to Feature-Driven Development
Strengthening the Case for Pair Programming
IEEE Software
Preliminary guidelines for empirical research in software engineering
IEEE Transactions on Software Engineering
Assessing test-driven development at IBM
Proceedings of the 25th International Conference on Software Engineering
An initial investigation of test driven development in industry
Proceedings of the 2003 ACM symposium on Applied computing
Using software testing to move students from trial-and-error to reflection-in-action
Proceedings of the 35th SIGCSE technical symposium on Computer science education
The Art of Software Testing
On the Effectiveness of the Test-First Approach to Programming
IEEE Transactions on Software Engineering
Design and Analysis of Experiments
Design and Analysis of Experiments
Evaluating performances of pair designing in industry
Journal of Systems and Software
Evaluating Pair Programming with Respect to System Complexity and Programmer Expertise
IEEE Transactions on Software Engineering
Guide to Advanced Empirical Software Engineering
Guide to Advanced Empirical Software Engineering
The impact of agile practices on communication in software development
Empirical Software Engineering
A survey of evidence for test-driven development in academia
ACM SIGCSE Bulletin
The Effect of Pairs in Program Design Tasks
IEEE Transactions on Software Engineering
Novice software developers, all over again
ICER '08 Proceedings of the Fourth international Workshop on Computing Education Research
The effectiveness of pair programming: A meta-analysis
Information and Software Technology
Automatic program repair with evolutionary computation
Communications of the ACM
Moving into a new software project landscape
Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering - Volume 1
A test-driven approach to code search and its application to the reuse of auxiliary functionality
Information and Software Technology
IEEE Transactions on Software Engineering
Hi-index | 0.00 |
A considerable part of software systems is comprised of functions that support the main modules, such as array or string manipulation and basic math computation. These auxiliary functions are usually considered less complex, and thus tend to receive less attention from developers. However, failures in these functions might propagate to more critical modules, thereby affecting the system's overall reliability. Given the complementary role of auxiliary functions, a question that arises is whether agile practices, such as pair programming and test-first programming, can improve their correctness without affecting time-to-market. This paper presents an empirical assessment comparing the application of these agile practices with more traditional approaches. Our study comprises independent experiments of pair versus solo programming, and test-first versus test-last programming. The first study involved 85 novice programmers who applied both traditional and agile approaches in the development of six auxiliary functions within three different domains. Our results suggest that the agile practices might bring benefits in this context. In particular, pair programmers delivered correct implementations much more often, and test-first programming encouraged the production of larger and higher coverage test sets. On the downside, the main experiment showed that both practices significantly increase total development time. A replication of the test-first experiment with professional developers shows similar results.