testdriven.com Wrangling quality out of chaos

For any software developer who has spent days in "integration hell," cobbling together myriad software components, Continuous Integration: Improving Software Quality and Reducing Risk illustrates how to transform integration from a necessary evil into an everyday part of the development process. The key, as the authors show, is to integrate regularly and often using continuous integration (CI) practices and techniques.

The authors first examine the concept of CI and its practices from the ground up and then move on to explore other effective processes performed by CI systems, such as database integration, testing, inspection, deployment, and feedback. Through more than forty CI-related practices using application examples in different languages, readers learn that CI leads to more rapid software development, produces deployable software at every step in the development lifecycle, and reduces the time between defect introduction and detection, saving time and lowering costs. With successful implementation of CI, developers reduce risks and repetitive manual processes, and teams receive better project visibility.

The book covers

* How to make integration a "non-event" on your software development projects
* How to reduce the amount of repetitive processes you perform when building your software
* Practices and techniques for using CI effectively with your teams
* Reducing the risks of late defect discovery, low-quality software, lack of visibility, and lack of deployable software
* Assessments of different CI servers and related tools on the market

Authors: Paul Duvall, Steve Matyas, Andrew Glover
Published: Addison-Wesley, June 29, 2007
336 pages
Companion web site
link

Refactoring has proven its value in a wide range of development projects–helping software professionals improve system designs, maintainability, extensibility, and performance. Now, for the first time, leading agile methodologist Scott Ambler and renowned consultant Pramodkumar Sadalage introduce powerful refactoring techniques specifically designed for database systems.

Ambler and Sadalage demonstrate how small changes to table structures, data, stored procedures, and triggers can significantly enhance virtually any database design–without changing semantics. You’ll learn how to evolve database schemas in step with source code–and become far more effective in projects relying on iterative, agile methodologies.

This comprehensive guide and reference helps you overcome the practical obstacles to refactoring real-world databases by covering every fundamental concept underlying database refactoring. Using start-to-finish examples, the authors walk you through refactoring simple standalone database applications as well as sophisticated multi-application scenarios. You’ll master every task involved in refactoring database schemas, and discover best practices for deploying refactorings in even the most complex production environments.

The second half of this book systematically covers five major categories of database refactorings. You’ll learn how to use refactoring to enhance database structure, data quality, and referential integrity; and how to refactor both architectures and methods. This book provides an extensive set of examples built with Oracle and Java and easily adaptable for other languages, such as C#, C++, or VB.NET, and other databases, such as DB2, SQL Server, MySQL, and Sybase.

Using this book’s techniques and examples, you can reduce waste, rework, risk, and cost–and build database systems capable of evolving smoothly, far into the future.

Authors: Scott W. Ambler & Pramodkumar J. Sadalage
Published: Addison-Wesley, March 3, 2006
link

See how to mine the experience of your software development team continually throughout the life of the project. The tools and recipes in this book will help you uncover and solve hidden (and not-so-hidden) problems with your technology, your methodology, and those difficult "people issues" on your team.

Project retrospectives help teams examine what went right and what went wrong on a project. But traditionally, retrospectives (also known as "post-mortems") are only held at the end of the project–too late to help. You need agile retrospectives that are iterative and incremental. You need to accurately find and fix problems to help the team today.

Now Esther and Diana show you the tools, tricks and tips you need to fix the problems you face on a software development project on an on-going basis. You’ll see how to architect retrospectives in general, how to design them specifically for your team and organization, how to run them effectively, how to make the needed changes and how to scale these techniques up. You’ll learn how to deal with problems, and implement solutions effectively throughout the project–not just at the end.

This book will help you:

* Design and run effective retrospectives
* Learn how to find and fix problems
* Find and reinforce team strengths
* Address people issues as well as technological
* Use tools and recipes proven in the real world

With regular tune-ups, your team will hum like a precise, world-class orchestra.

Authors: Esther Derby & Diana Larsen, foreword by Ken Schwaber
Published: July 26, 2006
link

The Practical, Start-to-Finish Guide to Planning and Leading Iterative Software Projects

Iterative processes have gained widespread acceptance because they help software developers reduce risk and cost, manage change, improve productivity, and deliver more effective, timely solutions. But conventional project management techniques don’t work well in iterative projects, and newer iterative management techniques have been poorly documented. Managing Iterative Software Development Projects is the solution: a relentlessly practical guide to planning, organizing, estimating, staffing, and managing any iterative project, from start to finish.

Leading iterative development experts Kurt Bittner and Ian Spence introduce a proven, scalable approach that improves both agility and control at the same time, satisfying the needs of developers, managers, and the business alike. Their techniques are easy to understand, and easy to use with any iterative methodology, from Rational Unified Process to Extreme Programming to the Microsoft Solutions Framework.

Whatever your role–team leader, program manager, project manager, developer, sponsor, or user representative–this book will help you

- Understand the key drivers of success in iterative projects
- Leverage “time boxing” to define project lifecycles and measure results
- Use Unified Process phases to facilitate controlled iterative development
- Master core concepts of iterative project management, including layering and evolution
- Create project roadmaps, including release plans
- Discover key patterns of risk management, estimation, organization, and iteration planning
- Understand what must be controlled centrally, and what you can safely delegate
- Transition smoothly to iterative processes
- Scale iterative project management from the smallest to the largest projects
- Align software investments with the needs of the business

Whether you are interested in software development using RUP, OpenUP, or other agile processes, this book will help you reduce the anxiety and cost associated with software improvement by providing an easy, non-intrusive path toward improved results–without overwhelming you and your team.

Authors: Kurt Bittner & Ian Spence
Published: Addison-Wesley Professional, June 27, 2006
672 pages
link

Agile methodologies, such as XP, Scrum, Crystal, and Lean Software Development enable development organizations to deliver higher-quality software far more rapidly. However, for the “non-agile” development organization, transitioning to agility is an enormous leap, requiring radically new skills and presenting profound risks.

In this book, leading agile practitioner Carol A. Wellington introduces the first systematic, three-phase process for moving smoothly to agility. Just as developers have learned to refactor code to improve performance and maintainability, Wellington shows how to refactor processes to improve agility.

Using Wellington’s framework, you can gradually move toward agility, while maintaining full control and avoiding disruption. You’ll lay a solid foundation for agility, and then refactor more and more of your processes, systematically introducing agility wherever it delivers compelling value. You can retain current processes that work, and implement the best agile methods for your organization, regardless of their source. This practical approach can help you build organizational confidence in agility, drive measurable benefits, and minimize risk every step of the way.

Coverage includes

- Phase 1: Time-boxed iterations that deliver customer-visible functionality–not just components
- Phase 2: A lightweight measurement process to detect problems and evaluate changes withoutwasting too much time gathering and analyzing data
- Phase 3: Identifying your worst process “smells,” uncovering their true underlying causes, and fixing them
- Incrementally bringing agility to planning, estimation, analysis, design, development, and process management
- Eliminating tasks and processes that don’t add value
- Overcoming pitfalls and hidden interconnections that complicate your agile transition
- Learning to lead the transition to agility, gaining buy-in from team members, customers, and executives

Whatever your role, organization, or current methodology, Refactoring to Agility can help you reap powerful value from agile methods–without the risks.

Dr. Carol A. Wellington is a professor of computer science and the department chair at Shippensburg University of Pennsylvania. Prior to this position, she was a leader in large software development organizations, building operating systems and real-time embedded applications. Dr. Wellington currently uses this combination of academic and industrial experience as a consultant to help companies question their assumptions about development processes to improve their agility and product quality.

Author: Carol A. Wellington
Published: Addison Wesley Professional, July 20, 2006
PDF only, 118 pages
link

Rails is large, powerful, and new. How do you use it effectively? How do you harness the power? And, most important, how do you get high-quality, real-world applications written?

From the latest Ajax effects to time-saving automation tips for your development process, Rails Recipes will show you how the experts have already solved the problems you have.

This book explains how to:

- Use generators to automate repetitive coding tasks.
- Create sophisticated role-based authentication schemes.
- Add live search and live preview to your site.
- Run tests when anyone checks code in.
- Create tagged data the right way.

Author: Chad Fowler
Published: Pragmatic Programmers, June 2006
350 pages

link

"Any process that prohibits any other best practices from being introduced is almost certainly a bad process."

* Use the right tools to guide and protect your project, and tame those that can hurt you
* Effectively manage features and issues to keep both users and managers happy
* Improve everyone’s communication and collaboration using simple techniques
* Recognize how great developers and great managers work in concert — and how to fix it when they don’t
* Know how to answer the Frequently Asked Questions and fix the common problems that everyone faces on modern projects

Authors: Jared Richardson and Will Gwaltney
Published: June 2005
link

In the last few years, two ostensibly conflicting approaches to software development have competed for hegemony. Agile method supporters released a manifesto that shifts the focus from traditional plan-driven, process-based methods to lighter, more adaptive paradigms. Traditional methods have reasserted the need for strong process discipline and rigorous practices. True believers on both sides have raised strident, often antagonistic, voices. We wrote this book for the rest of us, those caught in the middle of the method wars simply trying to get our projects completed and accepted within too-tight schedules and budgets. We hope to clarify the perplexity about the roles of discipline, agility, and process in software development. We objectively compare and contrast the traditional, plan-driven approaches to the newer, agile approaches and present an overview of their home grounds, strengths, and weaknesses. We then describe a risk-based approach to aid in balancing agility and discipline within a software development project.

- The first chapter sets the stage for what follows. It introduces the main points and provides an executive summary of the book.
- Chapter 2 compares the agile and plan-driven approaches and provides insight into the type of projects where each has been most successful (their home grounds).
- Chapter 3 provides an experiential introduction to the approaches by describing how both a typical and not-so-typical day might be spent using each.
- Chapter 4 presents two project case studies that illustrate the limits of pure agile and pure plan-driven implementations and the benefits of integrating the approaches.
- Chapter 5 describes a risk-based approach for making methodology decisions that integrate agile and plan-driven practices, and illustrates it with representative examples.
- Chapter 6 summarizes the material and offers some final observations.

Authors: Barry Boehm, Richard Turner
Published: Addison-Wesley Professional; 1st edition (August 15, 2003)
link

Maven is a new project management and comprehension tool which provides an elegant way to share build logic across projects. In terms of capabilities, Maven is an improvement to Apache Ant-thanks to numerous plug-ins and built-in integration with unit testing frameworks such as JUnit. Tired of writing the same build logic for every project? Using Maven, you can leverage the experience of the community to avoid the tedious process of creating yet another build script for each new project.

Maven: A Developer’s Notebook begins by introducing you to the concept of project object model (POM), and then offers further details on the essential features of Maven. Like all titles in O’Reilly’s Developer’s Notebook series, this no-nonsense book skips the boring prose and cuts right to the chase. It’s an approach that forces you to get your hands dirty by working through a series of poignant labs-exercises that speak to you instead of at you.

Plus, Maven: A Developer’s Notebook is the first book on the subject to hit the market, so you know the information is fresh and timely. If you’re a Java programmer, you’ll be armed with all the critical information you need to get up to speed on this powerful new build tool. You’ll discover how Maven can help you:

* manage a project’s build, reporting, and documentation, all from a central piece of information
* break a complex project into a series of smaller subprojects
* report on code quality, unit tests, code duplication, and project activity
* create a custom remote repository
* build simple and complex plug-ins

In the end, you’ll find yourself spending less time working on your project’s build system and more time working on your project’s code.

Authors: Vincent Massol & Timothy M. O’Brien
Published: June 20, 2005
See also: Chapter 1: Maven Jump-Start [PDF]
link

At first glance, building and deploying applications seem simple enough. But in fact, difficult releases without any confidence or processes backing them are very common. Integration and management of a new deployment can be laborious and fraught with risk. So as team size and volume of projects grow, management becomes more difficult and risk more pronounced.

This book is a guide to the implementation of good processes in a .NET environment. Author Marc Holmes focuses on actual implementation, and details patterns and anti-patterns to watch out for. He also provides a practical and in-depth look at NAnt and CruiseControl.NET, and solutions to common problem scenarios.

* Chapter 1 takes a look at a fictional scenario and then discusses principles and arguments for the introduction of automated delivery processes.
* Chapter 2 introduces NAnt and discusses the ins and outs of the tool itself.
* Chapter 3 covers in more depth at the core NAnt tasks we’re bound to come across, with some discussion of the merits of these.
* Chapter 4 takes a piece of software and shows how to begin implementing automated delivery through NAnt.
* Chapter 5 gets a little more complex and implements (and refactors) the same processes across multiple software systems with some more complex examples.
* Chapter 6 furthers the processes using continuous integration and CruiseControl.Net, once again refactoring as appropriate.
* Chapter 7 teaches how to extend NAnt and build a custom task.
* Chapter 8 covers some complex territory using Red Gate’s DB tools and some custom tasks to perform automated database integration.
* Chapter 9 introduces CodeSmith and XSLT to aid the processes through code (or script) generation techniques.
* Chapter 10 wraps up and considers what’s been accomplished, and what the future may hold.

Author: Mark Holmes
Published: APress, May 9, 2005
link

A chapter-by-chapter review of Robert C. Martin’s book, Agile Software Development, Principles, Patterns, and Practices.

Author: David Haydn

(via [url=http://www.adapdev.com/blogs/smccormack/PermaLink,guid,f745843b-4669-4a9a-93e6-2e58e7d47913.aspx]Sean McCormack[/url])
link

Pair programming is a simple, straightforward concept. Two programmers work side-by-side at one computer, continuously collaborating on the same design, algorithm, code, and test. It produces a higher quality of code in about half the time than that produced by the summation of their solitary efforts. However, nothing is simple where people and personalities are involved–especially people who are accustomed to working alone. The leap to pair programming for a variety of software development projects is one that yields many benefits. However, it is also one that requires careful thought and planning.

Written as instruction for team members and leaders new to pair programming and as an improvement guide for experienced pair programmers, Pair Programming Illuminated explains both the principles underlying this method and its best practices. The authors, drawing on their own extensive experience, explain what works and what does not, what should be emphasized and what should be avoided. Two case studies further illuminate pair programming in practice: one in the context of extreme programming (XP), with which it often is associated, and one linked to a more disciplined software engineering process.

Key topics include:
- Principles for selecting partners
- Practical advice, such as furniture set-up, pair rotation, and weeding out bad pairs
- Seven habits of effective pair programmers

Special appendices include:
- A pair programming tutorial
- An economic analysis of pair programming
- An introduction to test-driven development

With this book in hand, you will quickly discover how pair programming fits the needs of your own organization or project. You then will see exactly how to get started with this method, and how to do it right.

Author: Laurie Williams & Robert Kessler
Published: June 2002
See also: Noel Llopis’ review
link

Get more out of your legacy systems: more performance, functionality, reliability, and manageability

Is your code easy to change? Can you get nearly instantaneous feedback when you do change it? Do you understand it? If the answer to any of these questions is no, you have legacy code, and it is draining time and money away from your development efforts.

In this book, Michael Feathers offers start-to-finish strategies for working more effectively with large, untested legacy code bases. This book draws on material Michael created for his renowned Object Mentor seminars: techniques Michael has used in mentoring to help hundreds of developers, technical managers, and testers bring their legacy systems under control.

The topics covered include

- Understanding the mechanics of software change: adding features, fixing bugs, improving design, optimizing performance
- Getting legacy code into a test harness
- Writing tests that protect you against introducing new problems
- Techniques that can be used with any language or platform—with examples in Java, C++, C, and C#
- Accurately identifying where code changes need to be made
- Coping with legacy systems that aren’t object-oriented
- Handling applications that don’t seem to have any structure

This book also includes a catalog of twenty-four dependency-breaking techniques that help you work with program elements in isolation and make safer changes.

Author: Michael Feathers
Published: Prentice Hall PTR, September 22, 2004
Excerpt: Chapter 1: Changing Software and Legacy Code
link

Test-driven development (TDD) has become very popular in recent months. Until now there was only one textbook on the subject – Kent Beck’s. [url=http://www.testdriven.com/modules/mylinks/singlelink.php?cid=10&lid=43]Test-Driven Development: A Practical Guide[/url] by David Astels, was published in July 2003 and complements Beck’s original TDD work. This book is part of The COAD Series, named after Peter Coad, Borland’s Senior Vice President and Chief Strategist. The book itself is a little over 550 pages long and offers up-to-the-minute advice on how TDD can change your development and testing philosophy.

Author: Craig Murphy
link

This book describes how to establish user requirements that work, to save time and develop better software that meets users’ needs. Gathering user stories for acceptance tests and integrating them into an eXtreme Programming project contributes to its efficiency.

Author: Mike Cohn
Publication date: February 27, 2004
User Stories site: http://userstories.com/
User Stories group: http://groups.yahoo.com/group/userstories/
link

In addition to all the considerations with database access, session administration, etc., in PHP, Chapter 6 of the book covers the topic of test-driven development.

Author: George Schlossnagle
Published: December, 2003
link

This book includes a description of Agile Modeling Driven Design (AMDD) and Test-Driven Design (TDD) approaches, database refactoring, database encapsulation strategies, and tools that support evolutionary techniques.

Explains how Agile software developers often use object and relational database (RDB) technology together and as a result must overcome the impedance mismatch

Covers techniques for mapping objects to RDBs and for implementing concurrency control, referential integrity, shared business logic, security access control, reports, and XML

The agile foundation describes fundamental skills that all agile software developers require, particularly Agile DBAs

Includes object modeling, UML data modeling, data normalization, class normalization, and how to deal with legacy databases

Author: Scott Ambler
Published: October, 2003
See also:
Author’s description
Summary of Chap. 9 on Evolutionary Development
link

How to extend the Eclipse development environment–both in the narrow sense of writing code that makes the software do something new, and in the broad sense of participating in the Eclipse community. Specific coverage addresses extension points, markers, perspectives, and help. There’s also a guide to the Eclipse architecture, framed as a series of "pattern stories."

The book contains an introduction to test-driven plug-in development.

Authors: Erich Gamma, Kent Beck
Published: October 31, 2003
link

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.

Author: Robert C. Martin (ObjectMentor)
Published: October 15, 2002
link