testdriven.com Wrangling quality out of chaos

Dave Hoover introduces a practice halfway between Pair programming and TDD, and looks for a name: "I first experienced (what I will temporarily call) Ping Pong Development when I visited Object Mentor in 2002. I was attending their Java Language Immersion with Test Driven Development and I was the only student of Micah Martin for the entire week. We had fun."

Peter Hancock likes Martin Fowler’s take on Spreading Incrementalism, and wonders who’ll undertake the risk to push forward incremental software development.

Partly answering Peter’s concerns that few articles exist on TDD and Security, Johan Peeters reports on the JavaPolis panel discussion on Secure Agility/Agile Security held on December 16th: "Security professionals have long regarded agile development processes with suspicion, in spite of their reputation for improving software quality. I report on a panel discussion at JavaPolis confronting agile processes with security engineering." James Newkirk has been moving forward with the Bookmark Collection TDD showcase: read Storage Refactoring and Rethinking the name and the interface.

Simon Wacker shows how to use the Mock Objects framework now available in the as2lib (Flash MX 2004+ utilites) beta. (via TweenPix)

Jonathan de Halleux twists a unit test to write a missing wrapper around every type.

Joe Walnes uses a JUnit decorator to set the default timezone in his tests.

JS Greenwood thinks that Mock-oriented development is another sign of TDD gone bad.

Chris Blackburn looks for a better build system.

While shoveling snow, Jon Udell listens to Kent Beck’s presentation at the DeveloperTesting forum and extracts the quintessence thereof.

Michael Mahemoff offers a podcast on extreme programming.

Jeff Schoolcraft is a test-infected, born-again TTDer and he explains why.

In addition to a short take on legacy code and courage, Udi Dahan addresses some recent discussions on Mocks: "There has been some discussion recently in the TDD/Agile world about the cost/value tradeoff of using mock objects. To tell you the truth, I was surprised. Hearing about how mocks increase the complexity of the system, go against ‘doing the simplest thing’, etc, was rather unexpected." Read Mock Objects ? NO! Mock Interfaces!

ThoughtWorks’ Murray White predicts Agile methodologies will increase in popularity this coming year: "A central tenant of Agile is delivering valuable software quickly and constantly over the life of a project. 2005 will see more corporate IT shops adopting Agile processes, either in part or in whole, in reaction to the need to improve cost effectiveness, drive innovation, and deliver measurable business value."

Rick Hightower tries to get Spring pooling to work, and looks at the JUnit tests to understand how the code works: "The mantra in the community is that if it is not documented look at the JUnit test to see how it works (I agree with this mantra to a large extent). This usually work out well, until it doesn’t."

Vincent Massol wants unbreakable builds: "A thought struck me about a year back: what if we were able to prevent the continuous build from failing by design." Vincent then posts a unordered list of the main problems causing build-breaks that have been found on several projects. (see also ensuing discussion on TheServerSide)

Owen Rogers wonders about the simplest thing: "One common piece of advice that I often hear is that it is important not to confuse the simplest thing with the easiest thing. This tells me that the simplest thing is not (necessarily) the easiest thing to do: simple things are hard. All well and good, but it still leaves me asking the question: what is the simplest thing?" (see also Bill Venners’ interview with Ward Cunningham on the same topic)

Hans Nowak engages in an interesting discussion on static typing.

Sahil Malik does a quick performance test of interface vs. inheritance vs. generics in .NET.

Scott Hand describes software factories and considers TDD is key.

Owen Rogers ponders over how late is later when a developer postpones refactorings.

Christopher Judd posts lessons he’s learned from continuous integration with [url=http://www.testdriven.com/search.php?query=cruisecontrol&action=results]CruiseControl[/url].

Sara Ford starts a "what’s wrong with this test case code" series. She begins with Identifying false positives. She also shows why it’s better to LogPass than to LogFailure.

Scott Dockendorf blogs a follow-up to the Q&A session after his talk on Test Driven Development & .NET at the Plano .NET User Group, and also posts the slides and source code he used during the talk.

Len Holgate explains Why you’re missing the point if you use a framework to generate Mock Objects for you: "TDD is all about the design. By writing a test before you write production code you think about the interface that clients of the production code will need to use. You’re working as a client programmer and the tests will drive the design towards something that’s nice to use from a client perspective. This is a Good Thing. In fact it’s The Point!"

James Robertson attends the second meeting of the reorganized Maryland Agile/XP group and [url=http://www.cincomsmalltalk.com/blog/blogView?showComments=true&entry=3280602395]shares his impressions[/url] on the [url=http://www.testdriven.com/search.php?query=fitnesse&action=results]FitNesse[/url] demo.

JB Evain explains [url=http://blogs.dotnetguru.org/jbevain/index.php?title=type_6_ioc_weaving_the_dependency&more=1&c=1&tb=1&pb=1]Type 6 IoC[/url] with a MockSystem example.

While adding unit testing to an existing system, Brian Oxley runs into a problem and solves it with delegation: "We’re following the ancient dictum, any problem can be solved by introducing an extra level of indirection. Foo was already delegating doSomething() to Trouble; we just replaced that relationship with an extra level of delegation, Foo to NoTrouble to Trouble. Now I can mock or stub NoTrouble without needing access to Trouble."

Mike Hodnick finds Agile development for real and is thrilled: "I’m surprised that Agile Development hasn’t caught on more quickly in organizations. After finally being able to work on a project while practicing Agile Development, it feels so natural."

The Wikipedia has an entry on TDD.

Bruce Johnson makes The Case for Unit Testing: "The developers know that when a modified class passes the unit tests, it is much less likely to introduce further bugs. So, rather than thinking them a waste of time, the good developers I know relish the idea of creating unit tests. Perhaps this is one of the characteristics that the rest of us would do well to emulate."

Roy Osherove changes his mind and now thinks Mock Objects are wrong for database testing; whereas Steve Eichert likes how mocked databases help him get into a TDD zone. (see also David Intersimone’s entry on taking unit testing and code stubbing to the extreme and Andrew Newman’s post RDF, the ultimate Agile database)

As part of the Worldwide Cincom Smalltalk User Conference, James Robertson reports on a talk by Vassili Bykov and Joseph Pelrine: "What would you do differently, if your customer could only pay you for one day of software development? Especially if, by doing something different, he would be able to afford yet another day of software development? What would become important, and what would become less important?" Read [url=http://www.cincomsmalltalk.com/blog/blogView?showComments=true&entry=3279948738]XP in Cincon Smalltalk[/url].

Willem van den Ende wonders where XP fits in the Cynefin domains model.

Trey Hutcheson announces that "the biggest feature for the next version of CFNUnitBridge is going to be the ability to execute tests on the device/emulator remotely from the desktop". He then analyzes this problem from a technical perspective, and outlines some possible solutions.

Colin Bird reports on the first part and Howard van Rooijen shares his slides on the second part of a presentation on The Value of Agile Methods at a recent Microsoft Architecture Forum.

Kevin Lawrence follows up on a [url=http://www.testdriven.com/modules/newbb/viewtopic.php?topic_id=1520&forum=6]recent group discussion[/url] centered around the relative merits of TDD versus Design by Contract.

Thanks to Brian Button’s step-by-step Dives into TDD, Brian T. Likes now gets TDD and explains what made it click.

Michael Mahemoff is starting RiffCasts, with the first installment on Agile Software Development and Interfaces as Services (MP3 format), and is asking for feedback.

Phillip J. Eby is mocking wxPython.

Howard M. Lewis Ship, author of Tapestry in Action, has become a big fan of EasyMock.

Derek Sivers posts better habits for database-driven web-apps.

Brian Likes investigates test-driven SmartPart development: "So the SmartPart allows you do quickly create SharePoint WebParts and you can even debug those WebParts in a normal ASP.Net application, but what about using Test Driven Development (TDD)?"

Gunjan Doshi addresses the Single Claim Principle: "How many asserts can I have per test? Multiple? Only one? I feel that the number of asserts per test is not the goal. The goal is to use test-driven development to generate value producing simple code. To achieve that goal, if I have to use multiple asserts per test, I am ok with it."

JBoss makes available Preview 2 of EJB 3.0, whose goals are to greatly reduce development complexity, facilitate test-driven development, simplify EJBs so they resemble plain old Java objects (POJOs), and specify annotations for the object/relational mapping of entity beans with container-managed persistence.

Read and see Ward Cunningham’s thoughts on the Pattern movement here.

Dion Almaer’s classes want injection too!

Venkat Subramaniam replies to the question: Where should your unit tests go?

Chris Shiflett tests PHP with Perl…

Liz Barnett, Carey Schwaber, Carl Zetie and Kimberly Q. Dowling write a Forrester Research report entitled [url=http://www.forrester.com/Research/Document/Excerpt/0,7211,35860,00.html]Teams Begin Adopting Agile Processes – Development Teams Are Smaller And Work In Shorter Iterations[/url] (requires registration).

Brian Button continues living in the TDD pool with Dive 6 into the test-first Payroll System, coding up the input side.

Gordon Weakliem thinks not enough attention is given to people who know how to do test-first: "Searching just now, there are 172 results for Java in the greater Denver area, and only 10 for JUnit. That’s 162 companies that don’t care if you can write unit tests. These are minimum standards for decent development practices these days. Maybe you should just advertise that you’re looking for people who know JUnit and Ant; just asking for Java is setting the bar too low."

James Newkirk explains why variables in NUnit [TestFixture] Classes need to be static.

Thibaut Barrère [url=http://blogs.dotnetguru.org/tbarrere/?title=nunitforms_and_testdriven_net&more=1&c=1&tb=1&pb=1]tests a Windows Form[/url]: "Yesterday I started adding test to a windows form application. Until now I only tested non graphic libraries, but was concerned about how to lock the behavior of a graphic application. Graphic applications (both web and non-web) are usually very likely to regress from a functional point of view, and seem to generate a lot of support, maybe because an inspired gui tester has that kind of black magic skills to find new, undiscovered ways to use your application."

Vinny Carpenter discusses the book Expert One-on-One J2EE Development without EJB and highlights the chapter on TDD as one of his favorites.

Ben Curtis finds out about SimpleTest‘s Partial Mock Objects.

Scott Hanselman shares his list of favorites NUnit add-ins and is ecstatic about TestDriven.NET.

Brian Button keeps the momentum with Part 5 of the series on building a Payroll System test-first: "As promised, we are finally adding the input and output handling stuff. If you can recall from way back in installment one, I chose to implement this stuff last, because it wasn’t challenging and it wasn’t the core of the problem. In other words, I was pretty sure I could make it work when I had to, so I wasn’t worried about it. Well, since the meat of the story is now finished, I need to do my I/O, and here it is." He also gets thrilled by a pair refactoring session with Peter Provost.

SRK Prasad makes a nice summary of Sriram Shankar’s recent conference on how Test Driven Development proved useful at Google.

Roy Osherove shows how to extend NUnit with ease.

JS Greenwood sees TDD go bad: "Although Test Driven Development (TDD) is one of the greatest steps forwards in software engineering, especially when combined with the modern languages and testing frameworks (i.e. xUnit), there’s a definite anti-pattern lurking in there – Test Oriented Development."

Tim Shakarian posts the latest version of SecureQueryStrings, rewritten from the ground up in TDD fashion: "Version 2.0 of SecureQueryString gives us a lot more control over how we want to protect query strings. It’s also a nice example of TDD in practice. SecureQueryString is public domain and comes with the entire source including all unit tests."

Brian Button continues his series "Diving into TDD" with Take 3 and Part 4 of the TDD-built Payroll system.

DotNetJoe has become irremediably test-infected.

Julian Bucknall shares some answers on TDD.

James Newkirk looks at how tests in a TestFixture share common initialization code: "Create a method in the TestFixture, move common initialization code to the method, and execute the method prior to each test."

Nigel Parker outlines how to use test driven assemblies inside transformations.

Jake Good feels so… agile.

Simon Harris highlights the shortcomings of unit tests: "The problem is that tests don’t necessarily prove that the software does what it’s supposed to. Rather, tests prove that software works for the given scenarios and the assumptions made and the plain fact is that these do not always match reality."

Steven A. Newton points out that "putting together a continuous-integration-style automated build and deploy halfway through the project is exponentially more effort than starting off with one. At some point in the project, it may even be that the effort outweighs the gain".

On the fun side, Canadian Mind Products maintains chapters on How to write unmaintainable code.

DeveloperTesting made a Live Blog from SD Forum’s half-day forum on Test-Driven Development. Kent Beck was the keynote speaker.

James Newkirk shows an example of the Fake It (‘Til You Make It) technique.

Peter Hancock finds out that Database design and deployment can be evolutionary.

Udi Dahan mocks a unit.

Dave Bost reports on a full-day track on Microsoft Team System and highlights features of its built-in testing framework.

Brian Button posts Part Deux of his test-driven developed Payroll system.

Mike Spille tackles IoC.

FlexUnit is coming soon…

Jim Little finds the tradeoff between Mock Object complexity and Playground manageability, while Santosh Benjamin is asking for pointers.

Oliver Kiessler shows how to set up a project and unit tests with the karma J2EE framework.

Erik Bianchi points to a quirk in Unit-testing Flash.

Dave Thomas explains Dependency Injection with Ruby on Rails.

Peter Provost shares the result of a refactoring session with Brian Button to present the NUnit CrossThreadTestRunner, to run tests of multithreaded classes (with an usage example), and replies to questions Jamie Cansdale raised about the runner.

Sean McCormick (Zanebug) announces a beta of Codus, a code-generation tool for Object relational mapping, and is seeking beta testers.

Steven Webster announces the open-sourcing of FlexUnit.

Filippo Diotalevi reviews the book Spring Live 1.0, and likes Chapter 8 on Testing Spring Applications: "It covers a huge number of testing frameworks, and for each one gives some examples and hints for integrating it with Spring and with your test suite." See also Chapter 2 as a PDF on setting up unit tests with Spring.

Andreas Schaefer explains why unit tests are as important as the code itself (part 1, part 2).

Steve Rowe wonders about approaches to unit-testing.

Ward Cunnigham addresses programming language religiosity (video).

Sam Gentile explains how Testdriven.NET’s "Test With… Debugger" feature provides unit test debugging.

Keith Ray shows how to make code re-usable with Mock objects.

David Boschmans lists key motivations for iterative development.

Sara Ford explains nightly test cases.

InfoWorld’s Jon Udell mentions TDD as "one increasingly popular approach to finding bugs" in his article Source code analysis breaks new ground.

Alexis Hui wonders about PyUnit‘s assertion limitations (see all of testdriven.com’s resources on [url=http://testdriven.com/search.php?query=python&action=results]Python[/url]).

Tim Shakarian wonders where TDD fits when testing large scale applications.

John Tobler writes a short blog on Fit and Fitnesse and makes the point acceptance testing tools do not eliminate the need for TDD.

The Italian Agile Day will be held November 12 in Milan.

Ron Jacobs thinks TDD serves as a meter for judging the quality of open-source projects.

Andy Marks blogs about test suite smells.

Chromatic, Technical Editor of the O’Reilly Network, starts a series of Perl Katas with focus on testing:

"How do you find new ideas? One way is through code katas, short pieces of code that start your learning. This article is the first in a series of code kata for Perl programmers. All of these exercises take place in the context of writing tests for Perl programs.

"Why give examples in the context of testing? First, to promote the idea of writing tests. One of the best techniques of writing good, simple, and effective software is to practice test-driven development. Second, because writing tests well is challenging. It often pushes programmers to find creative solutions to difficult problems."

The first Kata challenge is Testing Taint.

Antony Marcano explains why it’s a good idea to decouple test data from test code.

Brian Marick gives help for customers, highlighting common problems met by customers and solutions found.

Dan Crevier is reading Test-Driven Development in Microsoft.NET, and cringes at refactorings affecting performance.

Jonathan Cogley presents the ultimate pair-programming setup.

Daniel Bradby reports on his first session with Dave Thomas and does a quick summary of the ways to inject mocks into code.

Mike Gunderloy wonders whether Edit and Continue is a Useful tool or disaster in waiting.

Dear Manager, Mike Clark has written an open letter to tell you why the developers in your team need a build machine.

Craig Andera makes the point that TDD is great, except when it isn’t: "Sometimes what you’re testing is a little more complicated, like a form. In cases like that, testing gets a bit more complicated too, because now you have to simulate a user clicking buttons and entering text."

Brian Marick returns from a SCRUM Master session addressing cross-functional teams issues with an abstract diagram, and finds test-first practice to act as a means of integration between teams.

Brendan Tompkins describes ReSharper as a TDD tool.

Trey Hutcheson finds out How to test remote code that targets the PocketPC.

Peter Provost finds out why XSLTUnit doesn’t work under Internet Explorer, and provides the missing registry entry that’ll make it work.

Clarke Ching relates a dinner discussion on Waterfall and chopsticks and gets inspired to ruthless comparisons of XP and Waterfall following a go at the XP Game.

Andreas Schaefer disagrees with the view that Unit Testing is only a safety net: "The only person responsible of the quality of the software is the author himself and he/she should be held accountable for that. Therefore, in my opinion, writing Unit tests is not just a good habit but an essential part of the deliverables."

Trond Andersen reviews an article on How to do unit testing in BEA Workshop.

DotNetJoe is looking for a TDD pet project.

Robert Watkins gets FIT and takes a preview peek at JWebFit (part of JWebUnit): "Installed JwebFit last night. Wasn’t too hard, all things considered, especially for a beta product that doesn’t even get distributed prebuilt. The documentation is pretty poor, but I could get the example from the main FIT site going easily enough, and I found a couple of example tests in the jWebFit source. So, enough dithering. Here’s what I did."

Roy Osherove introduces… the Osherove.Interception framework: "Following the Nunit Extensibility framework, I did some thinking and made a More generic framework for interception ability. That means that you can create your own interception attributes not only for unit testing but for real world applications as well."

Stuart Ervine is testing the GUI.

Scott McClure describes the day unit tests failed him.

Greg Ostravich posts a review of Pragmatic Project Automation

Mike Lorengo adds a repository to his Continuous Integration showcase, the Virtual Cellar.

Laurent Bossavit draws a parallel between learning a foreign language and test-first development.

Richard S. Tallent explains the reasons that made him create unit tests against data in a database.

Tom Ball addresses the problem with unit testing.

Trey Hutcheson shows how to test SqlServerCe components.

Mark Levison asks for better support for TDD in Winforms.

Rick Hightower posts 12 Practices of an Effective Development in a nutshell.

To answer his students’ questions, Trond Arve Wasskog explains XP vs. RUP. Some time ago, he mentioned a fun experiment with marshmallows and spaghettis which indicated agile defeats waterfall.

Roy Osherove introduces the Unofficial NUnit Extensibility Framework: "With this project you are now able to add any attribute you can think of to you NUnit (or any other xUnit tests) with the ease of simply deriving from a base class."

Michael Swanson spends some time making the latest versions of CruiseControl.NET (CC.NET), NAnt, NUnit, and FxCop work together. "Although I wasn’t able to achieve a perfect solution, I did find a configuration that is workable until CC.NET adds native MSBuild support."

Trey Hutcheson makes available the source code for CFNUnitBridge 0.2.

Jonathan Cogley starts a series of TDD teasers for ASP.NET developers.

Joe Walnes is a huuuge fan of TDD, but raises doubt as to 100% coverage and the Law of Diminishing Returns.

Low Kian Seong highlights a few pertinent entries on [url=http://www.iosn.net/Members/platypus/blog/daylist_html?year=2004&month=9&day=4]where to start with TDD in Python[/url].

Mike Roberts continues sharing what he’s learned in part 4 of Lessons from a successful Agile project. Read part one, two, three.

Jeff Mesnil addresses the best usage of Deprecation.

Gunnar Kutrjavets blogs about Best practice: daily investigation of the test case failures.

Perryn Fowler shares her impressions of Agitar as a TDD-enabling tool.

Allen Hollub mentions TDD and continuous testing as the primary methodology to prevent bugs in code, in his SD Times Java Watch article on First, or Best, to Market?.

Michael Swanson writes a summary of Ron Jeffries’ presentation at the XP West Michigan Users Group.

James Todd describes in detail how JXTA/WebStart nightly builds work.

Dave Astels tells you Why your code sucks.

MbUnit has moved to testdriven.net.

Roy Osherove will be doing a Webcast on TDD using NUnit for Microsoft Israel.

Matt Albrecht takes a first stab at JUnit IoC.

Sebastian Bergmann has added visualization of coverage to the latest version (2.1.0) of the Pear PHPUnit2 testing framework.

Dan Countryman tells what it’s been like since the company he works for stopped pairing.

Refactor! for Visual Studio.NET is currently under development and pre-release editions are available only to owners of the Developer Express .NET subscription.

Brian Marick has made available Chapter 2 of his draft book, Driving Projects With Examples. He is also co-teaching courses on Test-Driven Design with Mike Clark and Exploratory testing with Elizabeth Hendrickson.

SD Best practices carries live reports from the 2004 conference. See them here and read about Kent Beck’s Oprah moment (registration needed).

Keith Ray posts 8 reasons to do TDD.

Agile Auckland has a website.

Mike Lorengo takes us through the moves of creating a Virtual Cellar. He’s already defined the architecture, set up Subversion, and has just shared his user stories.