An early release copy of The Art of Unit Testing is now available.
Rick Mugridge and Ward Cunningham’s book on Frameworks for Integrated Tests (FIT), FIT for Developing Software, was recently published.
Net Objectives has put online chapters of Scott Bain’s upcoming book on Emergent Design: "This Emergent Design book is a work in progress in which you can participate. Rather than having contributions from readers only serve to spawn and inform a Second Edition, readers can make comments, suggestions, expose errata, ask and answer questions, in short, provide the essential feedback necessary to produce a better book, before the book is committed to paper."From the introduction:
<blockquote>The purpose of this book is to examine what we need, as software developers (or "programmers", if you like) to get that kind of value from what we do, and from each other, and from the practice itself. I’d like to take a step back, look at the nature of what we’re doing, and try to derive a set of best-practices, general wisdom, and specific patterns of activity that will elevate our business into a true "profession", with all the benefits that such a thing provides.
However, it’s not my intention to stay purely theoretical, as interesting as that might be. I want to talk about real things, about the aspects of software development that are too hard, that are too limiting, and to suggest better ways of going about this job that have more value to us.
My contract with you is this: Everything I will investigate, suggest, present, demonstrate, etc… will have as its core intent the goal of improving our lot as creators of software. No matter how interesting or compelling a thing might be, if there’s nothing "in it for us", then I’m going to leave it out.
One thesis I’m going to start off with right now is this: Software development, by its very nature, is a process of evolution. We do not analyze, design, and build; we create something that works, and is of high quality, and is valuable as it stands, and then we evolve it in stages toward the product that the world needs. I’ve got a long way to go to demonstrate this, and in order to get there I’m going to need a set of supportive concepts and techniques.</blockquote>
Go to Emergent Design’s Presentation page and related courses offered by NetObjectives, view the Table of Contents/Feedback page, or jump straight to chapters on [url=http://www.netobjectives.com/emergentdesign/download/paying_attention_to_disciplines_unit_testing%20.pdf]Unit Testing[/url] and Refactoring (PDF format).
COLORADO SPRINGS, COLORADO — Jeff Langr’s second book, [url=http://www.testdriven.com/modules/mylinks/singlelink.php?cid=17&lid=794]Agile Java: Crafting Code with Test-Driven Development[/url], provides a modern introduction to professional software development. Agile Java is slated to be released by Prentice Hall PTR in February 2005, shortly after Sun’s release of Java version 5.0. This code-intensive book teaches Java as a high-disciplined craft, using an object-oriented (OO) and test-driven approach from the ground up.Test-driven development (TDD) defines a rote technique for developers to incrementally craft high-quality code at a sustained pace. With TDD, developers learn to build systems using a fine-grained cycle of writing bits of test and code. TDD results in higher quality systems and provides comprehensive detailed system documentation.
TDD is a recent discovery that comes out of the extreme programming (XP) world. However, you don’t need to do XP or even understand it in order to learn and practice TDD. Most developers with TDD experience are thrilled by the value it brings them.
Agile Java stresses the importance of TDD by showing coded tests for every Java feature taught. A programmer learning with Agile Java understands how to translate oral requirements into tests, and tests into code. They also learn how TDD impacts the design of the system, and vice versa.
In short, readers of Agile Java will understand what it takes to build a professional, robust software system using Java.
– Presents a way of learning Java in conjunction with object-oriented design and test-driven development.
– Will seamlessly integrate the new, highly-anticipated language features of Java 5.0 into the learning experience.
– Approaches Java development as a craft, and demonstrates a proven means of learning and mastering the language as a craftsman.
– Is written by a recognized veteran software developer. Jeff Langr is the author of the praised book Essential Java Style, as well as several articles on software development. Langr has extensive experience in Java and TDD.
– Avoids approaching Java in the less effective C/C++-based fashion as the bulk of other available Java books.
– Provides additional value as a cookbook for doing TDD & Java.
– Uses TDD as a unique way of teaching a language. I and Object Mentor have successfully taught language courses using TDD as a driver. The TDD approach provides a very high amount of immediate feedback to students, something I believe is very valuable in the learning process.
– Is "XP-friendly"
– Shows the best way to take advantage of the new Java 5.0 language concepts using TDD
– Simplifies the learning of Java, TDD, and OO by teaching them simultaneously, not in a single-threaded fashion
– Presents many best practices for Java, TDD, and OO design
– Demonstrates that learning how to program well doesn’t need to be difficult
O’Reilly has announced the forthcoming publication of Unit test frameworks, a book that "explores unit testing as a language-independent, standalone development methodology".
Sample chapter available: "The xUnit Family of Unit Test Frameworks".
Due in bookstores later this month.
APress has posted three beta chapters from Test-Driven Development: A J2EE Example, for readers to provide feedback to the authors.Beta chapters available:
Introduction to Test Driven Development
Thomas Hammell introduces the theory of Test Driven Development (TDD) and explains its fundamental concepts and benefits. TDD is more than a nice idea. It is a proven methodology that can be used to simplify the development environment and help developers produce better software. Of course some things that sound good in theory are hard to put to practice. TDD is not that hard to put into practice but it does take some new knowledge and experience to properly implement.
This chapter introduces the tools needed to effectively perform TDD. It also introduces the requirements for the Football Pool application that will be used throughout the rest of the book. As described in the beginning of this chapter, it is important to take the time to set up your development environment to make it easy to create software. There are enough problems producing good software; so, you don’t want your development environment to get in the way.
Unit Testing: The Foundation of Test-Driven Development
In this chapter, Hammell puts the theory of chapter 1 and the tools discussed in chapter 2 into practice. He starts out by developing a simple unit test that should help you write the code for a base class belonging to the Football Pool application. This example show us how the JUnit testing framework works, and allows you to go through the test->code->build cycle the TDD way. Later in this chapter, Hammell illustrates how to use JUnit’s TestSuite to run a set of tests, as well as shows how Ant can be used to make the tests easier to run. Finally, this chapter shows how to develop around dependent classes.
The chapters come in both HTML and PDF formats.
Addison-Wesley has announced that a revised second edition of Kent Beck’s book, Extreme Programming: Embracing change, will be made available at the end of the month of October, 2004."Accountability. Transparency. Responsibility. These are not words that are often applied to software development.
"In this completely revised introduction to Extreme Programming (XP), Kent Beck describes how to improve your software development by integrating these highly desired concepts into your daily development process.
"The first edition of Extreme Programming Explained is a classic. It won awards for its then-radical ideas for improving small-team development, such as having developers write automated tests for their own code and having the whole team plan weekly. Much has changed in five years. This completely rewritten second edition expands the scope of XP to teams of any size by suggesting a program of continuous improvement that’s based on:
– Five core values consistent with excellence in software development
– Eleven principles for putting those values into action
– Thirteen primary and eleven corollary practices to help you push development past its current business and technical limitations
"Whether you have a small team that is already closely aligned with your customers, or a large team in a gigantic or multinational organization, you will find in these pages a wealth of ideas to challenge, inspire, and encourage you and your team member to improve your software development.
"You will discover how to:
– Involve the whole team–XP style
– Increase technical collaboration through pair programming and continuous integration
– Reduce defects with developer testing
– Align business and technical decisions through weekly and quarterly planning
– Improve teamwork by setting up an informative, shared workspace
"You will also find many other concrete ideas for improvement, all based on a philosophy that emphasizes simultaneously increasing the humanity and effectiveness of software development.
"Every team can improve. Every team can begin improving today. More improvement is possible beyond what we can currently imagine. Extreme Programming Explained, Second Edition, offers ideas to fuel your improvement for years to come."
Visit Addison-Wesley’s [url=http://www.awprofessional.com/title/0321278658?f1=nl;3;2004-10-05]book presentation page[/url].
Pre-order this book from Amazon.
I have posted a review of the book Pragmatic Project Automation on my website. Surf on over to http://www.binaryshift.com/main/clarkm-PPA-Java-review.m to find more about this book
"For refactoring to be valuable it must be going somewhere, not just an abstract intellectual exercise. Patterns document program structures with known good properties. Put the two together and you have Refactoring to Patterns. If you want your refactorings to go somewhere, I suggest you read and apply Refactoring to Patterns."
Kent Beck, Director, Three Rivers Institute
‘In the GoF book we claimed that design patterns are targets for refactorings. This book finally shows that we didn’t lie. By doing so, Joshua’s book will deepen your understanding of both refactoring and design patterns."
Erich Gamma, Eclipse Java Development Tools lead, IBM
"Now the connection between software patterns and agile development is finally told."
[url=http://www.testdriven.com/modules/mylinks/singlelink.php?cid=10&lid=543]Read more[/url] about Josh’s book.
Published in the Pragmatic Bookshelf series, Mike Clark’s book Pragmatic Project Automation is due out around July 17.Topics covered in the book:
* Discover how automation saves time and money
* Learn to use common, freely available tools to automate build, test, and release procedures.
* Learn effective ways to keep on top of problems for the whole team
* Use automation to create better code
* See how to create and deploy releases easily and automatically
* Explore techniques that let programs monitor themselves and report problems
TheServerSide.com and Prentice Hall have made available Frank Cohen’s book, Java Testing and Design, From Unit Testing to Automated Web Tests, as a PDF file.
The book teaches how to build production-worthy, scalable, and performant Web-enabled applications. It also presents techniques and tools to enable developers, QA technicians, and IT managers to work together in development and test automation.
I am compiling a catalog of all the patterns I see and use over and over when doing TDD in various flavours of XUnit (JUnit, VbUnit, RubyUnit, etc.) and I’d like your feedback!
The patterns and the narratives that introduce each topic area are available here. Each pattern has a DISCUSS button which takes you to a Wiki for entering feedback.
Pragmatic Testing in C# with NUnit, by Andy Hunt and Dave Thomas, which has been available as a PDF for a while, is now available for purchase.
Andy is happy to note that it’s the only book to cover the new NUnit 2.2 features, thanks to a close collaboration with Charlie Poole (NUnit development team).Book description, from The Pragmatic Programmers:
"Pragmatic programmers use feedback to drive their development and personal processes. The most valuable feedback you can get while coding comes from unit testing.
Without good tests in place, coding can become a frustrating game of ‘whack-a-mole.’ That’s the carnival game where the player strikes at a mechanical mole; it retreats and another mole pops up on the opposite side of the field. The moles pop up and down so fast that you end up flailing your mallet helplessly as the moles continue to pop up where you least expect them.
You don’t test a bridge by driving a single car over it right down the middle lane on a clear, calm day. Yet many programmers approach testing that same way — one pass right down the middle and they call it ‘tested.’ Pragmatic programmers can do better than that!
Real unit testing will make your life easier. It will make your designs better and drastically reduce the amount of time you spend debugging."
Read [url=http://www.toolshed.com/blog/News/CSharpPrinted.html,v]Andy Hunt’s blog entry on the book[/url].
Purchase a copy.
Another book on eXtreme Programming is due out later this month, with a specific focus on Test Driven Development techniques. It highlights continuous integration, load testing and Mock Objects testing.
"Professional Java Tools for Extreme Programming is a practical, code-intensive guide to the tools that Enterprise Java developers need when using Extreme Programming (XP) methods. It covers the key tools used to automate the most complex parts of the XP process: application integration, testing, and deployment."Part III of the book, "Automated J2EE testing", covers functional, struts and coverage testing.
Part IV of the book is entirely devoted to GUI unit-testing of Swing components using Jemmy, JFCUnit and Abbot.
Part V deals more specifically with Continuous integration tools.
The book covers major new releases of Ant, JUnit, and Cactus, plus important new tools, inlcuding XDoclet, Maven, Anthill, and Eclipse.
Authors: Richard Hightower, Nicholas Lesiecki, Maciej Zawadzki
Expected date of publication: April 26, 2004
"JUnit Recipes: Practical Methods for Programmer Testing", is a manual on using JUnit, to be published by Manning Publications in July.
The author, J. B. Rainsberger, is the president of Diaspar Software Services, an up-and-coming writer and public speaker. He is a prolific contributor to many TDD lists.To pre-order this book, click on the image below:
An excerpt: "JUnit: A Starter Guide", is available here.
Mike Gunderloy, author of the book "Coder to Developer" (scheduled for publication in early April), has made available a sample chapter entitled "Preventing bugs with Unit testing."Book description:
"Are you ready to take the leap from programmer to proficient developer? Based on the assumption that programmers need to grasp a broad set of core skills in order to develop high-quality software, Coder to Developer teaches you these critical ground rules. Topics covered include project planning, source code control, error handling strategies, working with and managing teams, documenting the application, developing a build process, and delivering the product. Most of the techniques taught in this unique book are language and platform neutral, and were selected to help you effectively design and develop complex applications."
View the Table of Contents.
To read the sample chapter (2Mb PDF file), click here.
Pre-order this book on Amazon.
Andy Hunt and Dave Thomas have completed their third book on unit-testing in C# with NUnit.
The authors have also decided to release the PDF version while the paper book is going into production.Purchasing the PDF now still entitles you to get the standard combo discount ($12.50) on the paper book when it arrives from the printers.
Authors: Andy Hunt & Dave Thomas
Published: March 2004
Read all about the book and buy the PDF here.
Agile requirements is about discovering what your users really want. With this book, you will:
– establish flexible, quick and practical requirements that work
– save time and develop better software that meets users’ needs
– gather user stories — even when you can’t talk to users
– learn how user stories work, and how they differ from use cases, scenarios, and traditional requirements
– leverage user stories as part of planning, scheduling, estimating, and testing
Author: Mike Cohn
Publication date: Expected February 27, 2004
Get the book at your local computer bookstore or from Amazon.
Visit the User Stories site and download draft chapters.
Join the User Stories group on Yahoo!Thoroughly reviewed and eagerly anticipated by the agile community, User Stories Applied offers a requirements process that saves time, eliminates rework, and leads directly to better software.
The best way to build software that meets users’ needs is to begin with "user stories": simple, clear, brief descriptions of functionality that will be valuable to real users. In User Stories Applied, Mike Cohn provides you with a front-to-back blueprint for writing these user stories and weaving them into your development lifecycle.
You’ll learn what makes a great user story, and what makes a bad one. You’ll discover practical ways to gather user stories, even when you can’t speak with your users. Then, once you’ve compiled your user stories, Cohn shows how to organize them, prioritize them, and use them for planning, management, and testing.
– User role modeling: understanding what users have in common, and where they differ
– Gathering stories: user interviewing, questionnaires, observation, and workshops
– Working with managers, trainers, salespeople and other "proxies"
– Writing user stories for acceptance testing
– Using stories to prioritize, set schedules, and estimate release costs
– Includes end-of-chapter practice questions and exercises
User Stories Applied will be invaluable to every software developer, tester, analyst, and manager working with any agile method: XP, Scrum… or even your own home-grown approach.
This book demonstrates how to apply the key concepts of TDD—including the use of customer stories, customer acceptance tests, and "Spikes"—and the fundamental techniques of Simple Design, Test-Driven Development, and Refactoring to create practical, .NET-ready applications. You’ll also learn how to use NUnit, a unit-testing tool for .NET languages.
Author: Ronald E. Jeffries
Publisher: Microsoft Press
Publication date: Expected in April, 2004
Pre-order this book on Amazon
Apply what you know about extreme programming and object-oriented design to learning C# and the Microsoft® .NET Framework on the fly. This essential, high-level reference provides the expert guidance, hands-on insights, and downloadable code you need to build an XML editor, a database application, a Web service, and other useful applications—quickly extending your extreme programming expertise to .NET and helping you deliver business value right away.
About the Author
Ronald E. Jeffries was the on-site coach for the original eXtreme programming (XP) project. An independent consultant who has been involved in XP for more than five years, he has presented numerous talks and published several papers on the topic. He and his teams have built operating systems, compilers, relational database systems, and a wide range of applications. He is the most prolific on-line author by far in eXtreme Programming and related topics.
A book on TDD in .NET is due out in February, 2004, entitled Test-Driven Development in Microsoft .Net — Learn How to Leverage Test-Driven Development in the .Net Platform, by James Newkirk and Alexei Vorontsov.
Description of the book:
"Learn how to apply the concepts and techniques of Test-Driven Development (TDD) to writing software for Microsoft .NET. Two experts in agile software development teach—using a wealth of pragmatic examples in C# and other .NET development tools—how to use automated tests to drive lean, efficient coding and better design. You’ll focus on .NET-specific issues for TDD, including the best time to employ the inherent features of .NET class libraries and how to use NUnit, a leading unit-testing framework for .NET. And you’ll see real-world examples of TDD-for .NET projects, including a Microsoft ADO.NET relational database, a user interface created with Microsoft ASP.NET and Microsoft Windows® Forms, Web services, and other useful applications."
Click here for more information on this book.
A guide to unit testing Java applications (including J2EE applications) using the JUnit framework and its extensions, this book provides techniques for solving real-world problems such as unit testing legacy applications, writing real tests for real objects, automating tests, testing in isolation, and unit testing J2EE and database applications.Using a sample-driven approach, various unit testing strategies are covered, such as how to unit test EJBs, database applications, and how to unit test JSPs, and Taglibs.
Also addressed are testing strategies using freely available open source frameworks and tools, and how to unit test in isolation with Mock Objects.
Testing J2EE applications by running tests from inside the container for performing integration unit tests is discussed, as is how to automate unit testing in automated builds (such as Ant and Maven) for performing continuous integration.
[img align=right]http://www.testdriven.com/uploads/img3fa12b57c8f4f.jpg[/img]Published: October, 2003
Further details about this book may be obtained from Amazon.
Vincent Massol is the creator of the Jakarta Cactus framework and an active member of the Maven, Gump, Struts, and MockObjects development teams. He is the cofounder and CTO of Pivolis, a company that specializes in applying agile methodologies to offshore software development.
Ted Husted is an active member of the Struts development team and the manager of the JGuru Struts Forum. His most recent development project uses test-driven design throughout and is available as open source [wqdata]. He is the author of Struts in Action. He lives in Fairport, New York.
A new book on test-driven development has just been published. This 480-page paperback book, published by Morgan Kaufmann, explains the process of TDD in Java, and covers the steps and pitfalls that may be encountered along the way.
Software testing is indispensable and is one of the most discussed topics in software development today. Many companies address this issue by assigning a dedicated software testing phase towards the end of their development cycle. However, quality cannot be tested into a buggy application. Early and continuous unit testing has been shown to be crucial for high quality software and low defect rates. Yet current books on testing ignore the developer’s point of view and give little guidance on how to bring the overwhelming amount of testing theory into practice. Unit Testing in Java represents a practical introduction to unit testing for software developers. It introduces the basic test-first approach and then discusses a large number of special issues and problem cases. The book instructs developers through each step and motivates them to explore further.
– Shows how tests written before the application is coded can ensure quality and evolutionary design.
– Tackles difficult topics such as persistency, concurrency, distribution, and web applications.
– Includes a discussion of testing with C++ and Smalltalk.
About the Author
For 4 years Johannes Link has been project manager and software developer at andrena objects ag in Karlsruhe, Germany. He came to andrena after years of practical software engineering research at the German Cancer Research Center and the German ABB Corporate Research Center. Johannes is responsible for andrena’s internal and external training activities and has published articles on software testing and software development. He holds a diploma degree in medical computer science from Heidelberg University.
Peter Fröhlich holds a MSc in computer science from the University of Aachen and a Ph.D. in electrical engineering from the University of Hannover. From 1998 to 2002, he worked for ABB Corporate Research as a developer, process improvement consultant, project manager, and manager of a research group. Since 2002 he has worked for Robert Bosch GmbH as a software architect. His research interests include process improvement, conceptual modeling, software architecture, and testing.