The subject matter of this book deals with solving the most challenging problems facing software developers, project managers, and software project leaders today. This comprehensive, pragmatic tutorial on Agile Development and eXtreme programming, written by one of the founding father of Agile Development, aims at teaching software developers and project managers how to get projects done on time, and on budget using the power of Agile Development; using real-world case studies to show how to of plan, test, refactor, and pair program using eXtreme programming; and focuses on solving customer oriented systems problems using UML and Design Patterns.
In this step-by-step series, the hero, a TDD beginner, learns to understand, by trial and error, what it means to practice test-first and refactorings. An easy and clear introduction to good programming practice through test-driven development.
Author: Robert C. Martin
Published: 13 February – 15 october 2002
These chapters are derived from Principles, Patterns, and Practices of Agile Software Development.
Industrial Logic is a dedicated team of XP coaches and programmers who’ve worked on small, large and distributed XP projects in the U.S. and abroad, since the early days of XP.
As XP leaders since 1999, we have pioneered the Industrial XP process to meet the needs of large and small organizations. Today, we are pleased to provide the following services: Industrial XP Coaching and Industrial XP Training.
Our XP services and training are available in the U.S. and abroad. We’d be happy to talk with you about your specific needs.
Test-Driven Development (TDD) is a practice for efficiently evolving useful code. While its name implies that it’s mostly about testing, test-driven development is primarily about design: it keeps programmers focused on exactly what they need to build and helps them avoid over-engineering. Using this technique, programmers write a failing test, write code to pass the test, refactor the code and repeat. TDD offers a rhythm of development that simplifies how programmers evolve lean, useful, fully tested software. We offer three flavors of TDD workshops:
A thorough demonstration of TDD will be performed by the workshop coaches, with comments and questions solicited from the participants.
In the interactive worshop, participants will get their hands dirty by using TDD to extend the demonstration code in our popular class fishbowl.
In the challenge worshop, participants will be given the task of writing a program to solve a specific problem using TDD. When everyone has completed the challenge (or we run out of time), we’ll discuss how participants implemented their solution and what it was like to do TDD.
Junit-addons Runner is a Junit runner that is especially targeted at integration tests, where external resources are too expensive to acquire before each test. Some of JUnit-addons Runner features include:
– custom listeners;
– resources (like a connection to a database) shared by tests;
– properties split for the runner and tests;
– custom monitor (to manage the execution of the tests).
This runner is very flexible (IMO) and was designed especially for
In our research, we ran a set of structured experiments with 24 professional pair programmers. One group developed code using TDD while the other a waterfall-like approach. Both groups developed a small Java program. We found that the TDD developers produced higher quality code, which passed 18% more functional black box test cases. However, TDD developer pairs took 16% more time for development. A moderate correlation between time spent and the resulting quality was established upon analysis.
Besides an introduction to refactoring, this handbook provides a catalog of dozens of tips for improving code. The best thing about Refactoring is its remarkably clear presentation, along with excellent nuts-and-bolts advice, from object expert Martin Fowler. The author is also an authority on software patterns and UML, and this experience helps make this a better book, one that should be immediately accessible to any intermediate or advanced object-oriented developer. (Just like patterns, each refactoring tip is presented with a simple name, a "motivation," and examples using Java and UML.)
Agile Development Conference http://agiledevelopmentconference.com/
June 25-28 in Salt Lake City, Utah.
Early registration discount through end of April.
Registration deadline: May 31.
When faced with a complex programming challenge, rare is the developer who can readily see how to begin or produce its solution. More often than not, such projects generate a great deal of stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean tasks, programmers should look to test-driven development (TDD), a proven set of techniques that encourage simple designs and test suites that inspire confidence.
Author: Kent Beck
Published: November 2002
Our goal is to help developers and development teams gain the skills, confidence, and clarity that will enable them to create better software with less cost, less suffering, and a greater sense of control. To do this, we offer a wide range of services including training, mentoring, and consulting. We positively impact our customers’ ability to develop quality software at an effective cost.
25952 SE 37th Way
Issaquah, WA 98029
Very roughly speaking, you usually have two choices when it comes to methodology. You can either use a "heavy" methodology with lots of design documents and procedures, or you can hack, doing whatever comes naturally along the path of least resistance. If you choose to hack, you can get a lot of features done quickly in the beginning, but as your application grows in complexity, you will be slowed down by hard-to-find bugs and the need to maintain duplicated code.
Agile methodologies such as XP attempt to solve this problem by doing less up-front design and making sure it is always possible to make design changes, and by constantly improving the structure of the code using a set of systematic procedures known as refactoring.
In XP, automatic testing of the produced software takes a central role in the development process. For unit tests, there are a multitude of freely available testing frameworks for many programming languages while there seems to be a complete lack of available testing frameworks for automating acceptance tests. At the department of Computer Science, Lund University, we felt the need for a light-weight acceptance testing framework that could be used in both students programming projects courses and in our own research projects.
This paper discusses the thoughts behind, and the implementation of, JaTack, a very lightweight framework for automating acceptance tests for batch-oriented programs.
Refactoring is about saying, "Let’s restructure this system in order to make it easier to change it." The corollary is that it’s pointless to refactor a system you will never change, because you’ll never get a payback. But if you will be changing the system—either to fix bugs or add features—keeping the system well factored or making it better factored will give you a payback as you make those changes.
An important part of any software development process is getting reliable builds of the software. Despite it’s importance, we are often surprised when this isn’t done. Here we discuss the process that Matt has put into place on a major project at ThoughtWorks, a process that is increasingly used throughout the company. It stresses a fully automated and reproducible build, including testing, that runs many times a day. This allows each developer to integrate daily thus reducing integration problems.
The abysmal quality of software has led to Extreme Programming (XP), a discipline for developing software that requires test-driven design, continuous testing and acceptance of constant change. As one application services provider (ASP) delivering complex demand chain management solutions has found, XP has enabled rapid development of quality software. The XP movement, which Kent Beck kicked off with a paper on Smalltalk programming, emphasizes testing that helps to bring new developers up to speed rapidly. It also aids developers when they refactor, or change, code. Every programmer writing code has to refactor existing code to streamline it, and continuous testing gives developers confidence that their refactoring works.
The key to working effectively with legacy code is getting it to a place where it is possible to know that you are making changes one at a time. When you can do that, you can nibble away at uncertainty incrementally. The tests that you use to do this are a bit different from traditional tests. I like to call them test coverings.
Mock objects are a powerful and flexible mechanism for substituting an imposter as a parameter to the class under test. In many cases, however, the collaborations with the class under test are not parameterized — for example: an attribute that is not supplied to the constructor; objects that are created or referenced via static factories; or new instances of collaborations that are created by the class.
Object Substitution is a technique developed by Polygenix to enable the developer to replace such collaborations with the class under test without modifying the original source code.
Acceptance tests must go beyond functionality to determine whether the packages meet goals such as specified performance levels. Automating end-to-end testing from the customer point of view can seem as daunting as driving along the edge of a cliff with no guard rail. At Tensegrent, a software engineering firm in Denver organized around XP practices, the developers and the tester have worked together to design modularized, self-verifying tests that can be quickly developed and easily maintained. This is accomplished through a combination of in-house and vendor-supplied tools.
Artima SuiteRunner, a free, open source unit and conformance testing toolkit for Java, was released in late January. Find out why the authors felt the need to create Artima SuiteRunner and learn how you can use it to run JUnit test suites.
The great thing about software patterns is that they convey many useful design ideas. It follows, therefore, that if you learn a bunch of these patterns, you’ll be a pretty good software designer, right? I considered myself just that once I’d learned and used dozens of patterns. They helped me develop flexible frameworks and build robust and extensible software systems. After a couple of years, however, I discovered that my knowledge of patterns and the way I used them frequently led me to over-engineer my work.
Abbot (A Better Bot) is a Java GUI testing framework. The framework may be invoked directly in hand-coded Java tests, or more simply using XML-based scripts. Both methods are designed to be used with the JUnit testing framework. You can launch a GUI, invoke arbitrary user actions on it, and examine its state. The scripts may be invoked from JUnit or with minor modification any other testing environment.
JUnit is a regression testing framework written by Erich Gamma and Kent Beck. It is used by the developer who implements unit tests in Java. Most famous of XUnits, JUnit is Open Source Software.
4th International Conference on eXtreme Programming and Agile Processes in Software Engineering – XP2003
Week of May 26, 2003, Genova, Italy