This is my short cut, published by Addison-Wesley, on the topic of a technique I dubbed "transition testing."
I view this technique as a critical piece of database agility.
This is my short cut, published by Addison-Wesley, on the topic of a technique I dubbed "transition testing."
I view this technique as a critical piece of database agility.
Agile principles have been a breath of fresh air to many development teams stuck in the middle of a rigid, process-driven environment. Unfortunately, it’s not so easy to bring Agile into an existing organization with established people and practices. Becoming Agile shows you practical techniques and strategies to move from your existing process to an Agile process without starting from scratch.
Many books discuss Agile from a theoretical or academic perspective. Becoming Agile takes a different approach and focuses on explaining Agile from a ground-level point-of-view. Author Greg Smith, a certified ScrumMaster with dozens of Agile projects under his belt, presents Agile principles in the context of a case study that flows throughout the book.
Becoming Agile focuses on the importance of adapting Agile principles to the realities of your environment. While Agile purists have often discouraged a "partial-Agile" approach, the reality is that in many shops a "purist" approach simply isn’t a viable option. Over the last few years, Agile authorities have begun to discover that the best deployments of Agile are often customized to the specific situation of a given company.
As well, Becoming Agile addresses the cultural realities of deploying Agile and how to deal with the needs of executives, managers, and the development team during migration. The author discusses employee motivation and establishing incentives that reward support of Agile techniques.
Becoming Agile will show you how to create a custom Agile process that supports the realities of your environment. The process will minimize risk as you transition to Agile iteratively, allowing time for your culture and processes to acclimate to Agile principles.
Author: Greg Smith
Expected publication date: Manning, April 2008
(Early Access Program available)
Most developers recognize the value of unit testing — the independent testing of individual chunks, units, of code by the developer while an application is being written. Unit testing leads to easier maintenance, troubleshooting, refactoring, and integration testing of the application. To facilitate unit testing, the developer uses unit-testing frameworks such as NUnit along with various helper frameworks for more advanced testing of interaction between objects — often called "Mock Object frameworks."
Because there are few clear and defined ways on how to write unit tests well, many shops try to implement unit tests on their code, realizing too late that the tests hinder the coding cycle more than they help. This book will help you avoid mistakes when writing unit tests, and show you how to do it right — from the beginning steps to the most advanced techniques.
The Art of Unit Testing guides the reader on the journey from beginner to master in the subtle art of unit testing. Based on expert author Roy Osherove’s real-world development experiences, this book shows developers how to make sure the code that they write actually works as expected, and how to make these verifications as automated as possible. Not only that, the book shows techniques that help to make sure that the tests are maintainable, readable, and test the right thing over time, avoiding the "throw-away tests" phenomenon that plagues many shops that try to write unit tests without clear guidelines. In this way it helps you make your development process — and your business — more agile.
The Art of Unit Testing starts out with the basics of how to write unit tests, what makes a good unit test, and how to avoid the pitfalls you may encounter when you try to write unit tests. You’ll learn to build tests that are readable, accurate, and maintainable. Along the way, you’ll pick up a set of best practices and how-tos for key subjects, from using test frameworks to using Mock Objects to writing tests that run against a database.
The author establishes five rules for good unit tests built upon the three major principles that any good test be maintainable, trustworthy, and readable. You’ll find clear sections presenting established best practices to ensure that your tests will adhere to these principles. The book also provides clear guidance on what to test and where to start testing when you’re going into a legacy code project.
Unlike other books on this topic, this book trades theory for real-world examples. It’s designed so that you, a working developer, can start writing better unit tests now.
Author: Roy Osherove
Expected publication date: Manning, April 2008
(Early Access Program available)
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
As more and more people move towards adoption of Agile practices, they are looking for guidance and advice on how to adopt Agile successfully. Unfortunately many of the questions they have such as: "Where do I start?", "What specific practices should I adopt?", "How can I adopt incrementally?" and "Where can I expect pitfalls?" are not adequately addressed.
This book answers these questions by guiding the reader in crafting their own adoption strategy focused on their business values and environment. This strategy is then directly tied to patterns of agile practice adoption that describe how many teams have successfully (and unsuccessfully) adopted practices like test-first development, simple design, and others.
Author: Amr Elssamadisy
Published: Lulu.com, June 28, 2007
In test-driven development, you first write an executable test of what your application code must do. Only then do you write the code itself and, with the test spurring you on, improve your design. In acceptance test-driven development (ATDD), you use the same technique to implement product features, benefiting from iterative development, rapid feedback cycles, and better-defined requirements. TDD and its supporting tools and techniques lead to better software faster.
Test Driven brings under one cover practical TDD techniques distilled from several years of community experience. With examples in Java and the Java EE environment, it explores both the techniques and the mindset of TDD and ATDD. It uses carefully chosen examples to illustrate TDD tools and design patterns, not in the abstract but concretely in the context of the technologies you face at work. It is accessible to TDD beginners, and it offers effective and less-well-known techniques to older TDD hands.
Author: Lasse Koskela
Published: Manning Publications, October 10, 2007
The content found on this site will eventually be compiled into Refactoring, Ruby Edition. With Martin Fowler’s permission, the existing examples found in Refactoring: Improving the Design of Existing Code are converted from Java to Ruby and explore any additional Refactorings that may pertain to Ruby development. The first phase of the project is the conversion process and the second is the Ruby specific content addition.
This website will be continually updated to show our progress.
Authors: Ali Aghareza, Stephen Chu, Jay Fields & John Hume
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
The definitive, Jolt-award winning guide to learning and using Rails is now in its Second Edition. Rails is a new approach to web-based application development that enables developers to create full-featured, sophisticated web-based applications using less code and less effort. Now programmers can get the job done right and still leave work on time.
NEW IN THE SECOND EDITION: The book has been updated to take advantage of all the new Rails 1.2 features. The sample application uses migrations, Ajax, features a REST interface, and illustrates new Rails features. There are new chapters on migrations, active support, active record, and action controller (including the new resources-based routing). The Web 2.0 and Deployment chapters have been completely rewritten to reflect the latest thinking. Now you can learn which environments are best for your style application, and see how Capistrano makes managing your site simple. All the remaining chapters have been extensively updated. Finally, hundreds of comments from readers of the first edition have been incorporated, making this book simply the best available.
Rails is a full-stack, open-source web framework that enables you to create full-featured, sophisticated web-based applications with a twist…you can create a full Rails application using less code than the setup XML you’d need just to configure some other frameworks.
You’ll see how easy it is to deploy Rails. You’ll be writing applications that work with your favorite database (MySQL, Oracle, Postgres, and more) in no time at all.
Authors: Dave Thomas, and David Heinemeier Hansson with Leon Breedt, Mike Clark, James Duncan Davidson, Justin Gehtland, and Andreas Schwarz
Published: Pragmatic Programmers, December 13, 2006
In 2003, Mary and Tom Poppendieck’s Lean Software Development introduced breakthrough development techniques that leverage Lean principles to deliver unprecedented agility and value. Now their widely anticipated sequel and companion guide shows exactly how to implement Lean software development, hands-on.
This new book draws on the Poppendiecks’ unparalleled experience helping development organizations optimize the entire software value stream. You’ll discover the right questions to ask, the key issues to focus on, and techniques proven to work. The authors present case studies from leading-edge software organizations, and offer practical exercises for jumpstarting your own Lean initiatives.
* Managing to extend, nourish, and leverage agile practices
* Building true development teams, not just groups
* Driving quality through rapid feedback and detailed discipline
* Making decisions Just-in-Time, but no later
* Delivering fast: How PatientKeeper delivers 45 rock-solid releases per year
* Making tradeoffs that really satisfy customers
Implementing Lean Software Development is indispensable to anyone who wants more effective development processes–managers, project leaders, senior developers, and architects in enterprise IT and software companies alike.
Authors: Mary & Tom Poppendieck
Published: Addison-Wesley Professional, September 7, 2006
With the award-winning book Agile Software Development: Principles, Patterns, and Practices, Robert C. Martin helped bring Agile principles to tens of thousands of Java and C++ programmers. Now .NET programmers have a definitive guide to agile methods with this completely updated volume from Robert C. Martin and Micah Martin, Agile Principles, Patterns, and Practices in C#.
This book presents a series of case studies illustrating the fundamentals of Agile development and Agile design, and moves quickly from UML models to real C# code. The introductory chapters lay out the basics of the agile movement, while the later chapters show proven techniques in action. The book includes many source code examples that are also available for download from the authors’ Web site.
Readers will come away from this book understanding
* Agile principles, and the fourteen practices of Extreme Programming
* Spiking, splitting, velocity, and planning iterations and releases
* Test-driven development, test-first design, and acceptance testing
* Refactoring with unit testing
* Pair programming
* Agile design and design smells
* The five types of UML diagrams and how to use them effectively
* Object-oriented package design and design patterns
* How to put all of it together for a real-world project
Whether you are a C# programmer or a Visual Basic or Java programmer learning C#, a software development manager, or a business analyst, Agile Principles, Patterns, and Practices in C# is the first book you should read to understand agile software and how it applies to programming in the .NET Framework.
Authors: Robert C. Martin & Micah Martin
Published: Prentice-Hall, July 20, 2006
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
James Shore has been writing a book on agile development to be published by O’Reilly. It’s called The Art of Agile Development and is a joint effort between James and chromatic, author of the Extreme Programming Pocket Guide.
Sections of the book have been published to allow Agile developers to be part of the review process.
The book’s aim is to provide an intensely practical reference that shows mainstream development teams how to adopt and use agile software development.
The book is divided in three sections: The Big Picture, Practicing XP, and Beyond XP. Part 2 is the heart of the book, containing all of the practices to form a complete agile methodology; it’s divided into six chapters: Thinking, Collaborating, Planning, Managing Code, Developing, and Deploying.
Authors: James Shore, Shane Warden
Expected date of publication: O’Reilly, November 2007
Agile Java™ Development With Spring, Hibernate and Eclipse is a book about robust technologies and effective methods which help bring simplicity back into the world of enterprise Java development. The three key technologies covered in this book, the Spring Framework, Hibernate and Eclipse, help reduce the complexity of enterprise Java development significantly.
Furthermore, these technologies enable plain old Java objects (POJOs) to be deployed in light-weight containers versus heavy-handed remote objects that require heavy EJB containers. This book also extensively covers technologies such as Ant, JUnit, JSP tag libraries and touches upon other areas such as such logging, GUI based debugging, monitoring using JMX, job scheduling, emailing, and more. Also, Extreme Programming (XP), Agile Model Driven Development (AMDD) and refactoring are methods that can expedite the software development projects by reducing the amount of up front requirements and design; hence these methods are embedded throughout the book but with just enough details and examples to not sidetrack the focus of this book.
In addition, this book contains well separated, subjective material (opinion sidebars), comic illustrations, tips and tricks, all of which provide real-world and practical perspectives on relevant topics. Last but not least, this book demonstrates the complete lifecycle by building and following a sample application, chapter-by-chapter, starting from conceptualization to production using the technology and processes covered in this book.
In summary, by using the technologies and methods covered in this book, the reader will be able to effectively develop enterprise-class Java applications, in an agile manner!
Author: Anil Hemrajani
Published: Sams, May 9, 2006
Sample chapter: [url=http://www.informit.com/articles/article.asp?p=518907&rl=1]How to Use XP and AMDD-Based Architecture and Design Modeling[/url]
Automated unit tests (A.K.A. "developer tests") and functional tests (A.K.A. "customer tests") are a cornerstone of many agile development methods (such as eXtreme Programming). The availability of automated, self-checking tests allows developers to be much bolder in how they modify existing software. They allow a more evolutionary form of software development that support incremental delivery of functionality to the customer (motto: Deliver early; deliver often!) that speeds up user feedback and improves the quality (both "fitness for purpose" and "software quality") of the software being built. The techniques are also spreading to less agile development methods via the introduction of "Test Driven Development" as a less extreme process alternative.
Automated test are more repeatable than manual tests because they execute exactly the same way every time. They don’t forget things after long weekends and vacations. They don’t leave to work on other projects. They don’t get sick or run over by a bus.
Automated tests take a lot less effort to run than manual tests. As a result, they are more likely to be run often. The more often the better. Fully assimilated agile developers run their tests pretty well every time they save and compile their code. And any time they need a quick vote of confidence! The tests act as a comforting "safety net" that promises to catch the developer’s mistakes. This allows them to work more quickly and with less paranoia and that makes them more productive despite the extra effort involved in writing the tests.
The XUnit patterns site was assembled to catalog the good practices in xUnit test automation the author has encountered over the years. It came about as a result of discussions Gerard Meszaros and Shaun Smith about the testing techniques they found themselves using over and over again to solve particular xUnit test automation problems.
Author: Gerard Meszaros
Published: Addison-Wesley Professional, May 21, 2007
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
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.
– 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
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
A series of chapters patterned after Jeff Langr’s book, Agile Java: Crafting Code with Test-Driven Development:
This isn’t academic fluff; follow these ideas and you’ll show yourself, your teammates, and your managers real results. These are the proven and effective agile practices that will make you a better developer.
This book will help you improve many different areas of your career:
* Beginning and Feeding Agility
* Delivering What Users Really Want
* Using personal Agile techniques for Coding, Debugging, and Feedback
* Using collaborative techniques for better Teamwork
* Moving to Agility
These practices provide guidelines that will help you succeed in delivering and meeting your user’s expectations, even if the domain is unfamiliar. You’ll be able to keep normal project pressure from turning into disastrous stress while writing code, and see how to effectively coordinate mentors, team leads, and developers in harmony.
You can learn all this stuff the hard way, but this book can save you time and pain. Read it today, and you’ll be a better developer. Today.
Authors: Venkat Subramaniam & Andy Hunt
Published: The Pragmatic Programmers, April 2006
"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
Typical enterprises use dozens, hundreds, and sometimes even thousands of applications, components, services, and databases. These run on heterogeneous operating systems and hardware, they use databases and messaging systems from various vendors, and they were written in different programming languages. And it’s your job to make them work together.
This book shows you how the power and elegance of Ruby can greatly simplify your job. Use it as a glue language to bind your enterprise applications using technologies including:
* Oracle, MySQL, and friends: use relational databases directly, and via mapping layers such as ActiveRecord.
* LDAP: Harness the power of directory services.
* XML Documents: create, validate, and read XML documents for easy information interchange
* Sockets, HTTP, and REST: sometimes the low-level communications protocols are the simplest way to get things moving.
* XML-RPC, SOAP, CORBA, RMI and others: and sometimes you need the high-level protocols to get the job done
This isn’t a book full of theory. Maik builds real life applications to illustrate all the techniques and technologies. It isn’t a love fest either: Maik isn’t afraid to point out the weaknesses in the approaches and in the libraries he’s describing.
Author: Maik Schmidt
Published: The Pragmatic Programmers, April 2006
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)
When we look at the efforts of most software developers we see a lot of energy being wasted. In the rush to get software completed, there is often little time to reflect on how to improve the way we do things, how to get that special fitness, balance and agility that allow us to be graceful in our intellectual efforts in order to achieve inspired results — with less effort.
We get unbalanced when we have to fix old bugs, losing flow. We often have to speculate about what’s needed, and feedback too slow. Our software becomes less than elegant and is hard to change, with tensions and stresses buiding up in us and in our software.
This book is intended to help improve your fitness and agility in two areas of software development where we can make huge improvements to current practice.
First, how to improve communication between the people who need the software and the people who develop it. Second, how to use automated testing to provide immediate and effective feedback so we can maintain balance and agility, and avoid "injury".
The book also questions some common assumptions about the way in which software is developed. But we don’t expect that you’ll make a big leap of faith; we start with current practice and show how you make small, yet effective improvements.
Authors: Rick Mugridge and Ward Cunningham
Published: Prentice-Hall, July 8, 2005