From the Editor of Methods & Tools » TDD

Ten Articles to Learn More on Test-Driven Development (TDD)

The Editor — Mon, 03 May 2010 11:56:58 +0000

The software development articles directory has just passed the mark of 2000 articles categorized in its database. Test-Driven Development (TDD) is currently a topic of debate in the software development community, as even the value of unit testing is questioned. Here is my selection of 10 interesting TDD articles that should help you get more knowledge on this topic. I have tried to find items that could apply more specifically to different programming languages.

* Improving Application Quality Using Test-Driven Development (TDD)

* Introduction to Test Driven Design (TDD)

* TDD from scratch

* Demystifying Extreme Programming: Test-Driven Programming

* TDD – FDD – BDD… Why not PDD?

* Using JMock in Test Driven Development

* Mocking the Embedded World: Test-Driven Development, Continuous Integration, and Design Patterns

* Test-Driven Development in Python

* Apply Test-Driven Development to your Database Projects

* Unit testing and Test Driven Development (TDD) for Flex and ActionScript 3.0

Growing Object-Oriented Software, Guided by Tests

The Editor — Fri, 23 Apr 2010 07:56:18 +0000

Object orientation (OO) is not a trendy concept these days, but it hasn’t certainly lost it values. The purpose of this book is to integrate the development of object oriented software with the test-driven development (TDD) approach, more specifically in Java. It starts with an introduction to TDD and the tools (Junit, jMock2) that will be used. It describes then in detail the TDD process that is then illustrated by a large example. The book ends with more software testing topics like tests smells or tests readability. A final part is dedicated to special aspects of testing like persistence, threads and asynchronous code.

The book could be read from start to end or be used as a reference book. In the preface, the authors say that the book is intended for developers with professional experience and some first knowledge of TDD. It really goes far beyond “toy” examples that you can find in programming learning books. The content is a balanced mix of concepts, examples and diagrams that makes it easy to read. Besides what could be considered “catchy” acronyms (OO+TDD), this book is an excellent reference on how to design and program software (the authors use the nice concept of “growing” software). I will consider it a must for anyone programming in Java, but I will also recommend it to people programming in other languages, as the thinking process could be applied in other contexts and with similar tools.

Reference: “Growing Object-Oriented Software, Guided by Tests”, Steve Freeman, Nat Pryce, Addison-Wesley, 358 pages, ISBN 978-0-321-50362-7

Get more details on this book or buy it on amazon.com
Get more details on this book or buy it on amazon.co.uk

Quotes

“What if software wasn’t “made”, like we make a paper airplane – finish folding it and fly it away? What if, instead, we treated software more like a valuable, productive plant, to be nurtured, pruned, harvested, fertilized, and watered? Traditional farmers know how to keep plants productive for decades or even centuries. How would software development be different if we treated our programs the same way?”

“As John Gall wrote in “The Systems Bible: The Beginner’s Guide to Systems Large and Small”: a complex systems that works is invariably found to have evolved from a simple system that works”.

“Sometimes we find it difficult to write a test for some functionality we want to add to our code. In our experience, this usually means that our design can be improved – perhaps the class is too tightly coupled to its environment or does not have clear responsibilities. When this happens, we first check whether it’s an opportunity to improve our code, before working around the design by making the test more complicated or using more sophisticated tools. We’ve found that the qualities that make an object easy to test also make our code responsive to change.”

Linkopedia June 2009

The Editor — Wed, 10 Jun 2009 16:32:58 +0000

How TDD and Pairing Increase Production

Continuous Integration On A Real, Big Project

Agile is NOT a Project Management Methodology

SmartGWT is a GWT based framework that allows you to not only utilize its comprehensive widget library for your application UI.

Webmasters and web developers can use Page Speed to evaluate the performance of their web pages and to get suggestions on how to improve them.

Article: How Scrum Helped Our Team

Article: A multi-tier architecture for building RESTful Web services

Video: Applying User Testing During Development

Video: Practical Functional JavaScript

Video Interview: Bas Vodde on Large Scale Scrum

Video: Effective Java Reloaded

Find more interesting links on the software development links directory, the software development tools directory, the software development articles directory, the software development blogs aggregator or the software development videos directory.

Looking for Agile Blogs

The Editor — Mon, 09 Mar 2009 15:30:45 +0000

I have recently created a new web site AgileVoices.com that aggregates for RSS feeds concerning agile software development. If you know about a good blog feed that is missing from the current roster, I would be please to add it. Thanks for your cooperation.

Summer 2008 Issue of Methods & Tools

The Editor — Mon, 23 Jun 2008 15:17:24 +0000

Methods & Tools is a free e-newsletter for software developers, testers and project managers. Summer 2008 issue’s content:
* UML versus Domain-Specific Languages
* We Increment to Adapt, We Iterate to Improve
* Building Products with Acceptance TDD
* Getting and Keeping Control over your Project

60 pages of software development knowledge.

To download or read this issue go to http://www.methodsandtools.com/

The Three Rules of Test Driven Development

The Editor — Mon, 03 Mar 2008 14:45:53 +0000

Over the years I have come to describe Test Driven Development in terms of three simple rules. They are:
1. You are not allowed to write any production code unless it is to make a failing unit test pass.
2. You are not allowed to write any more of a unit test than is sufficient to fail; and compilation failures are failures.
3. You are not allowed to write any more production code than is sufficient to pass the one failing unit test.

You must begin by writing a unit test for the functionality that you intend to write. But by rule 2, you can’t write very much of that unit test. As soon as the unit test code fails to compile, or fails an assertion, you must stop and write production code. But by rule 3 you can only write the production code that makes the test compile or pass, and no more.

If you think about this you will realize that you simply cannot write very much code at all without compiling and executing something. Indeed, this is really the point. In everything we do, whether writing tests, writing production code, or refactoring, we keep the system executing at all times. The time between running tests is on the order of seconds, or minutes. Even 10 minutes is too long.

Robert Martin

http://butunclebob.com/ArticleS.UncleBob.TheThreeRulesOfTdd

Besides these rules and independently of an agile approach, I always like as a developer being able to verify quickly my code, because it makes much more easier to find all the errors I do ;o)