- Paperback: 336 pages
- Publisher: Addison-Wesley Professional; 1 edition (July 9, 2007)
- Language: English
- ISBN-10: 9780321336385
- ISBN-13: 978-0321336385
- ASIN: 0321336380
- Product Dimensions: 7 x 0.9 x 9.1 inches
- Shipping Weight: 1.1 pounds (View shipping rates and policies)
- Average Customer Review: 30 customer reviews
- Amazon Best Sellers Rank: #277,241 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Continuous Integration: Improving Software Quality and Reducing Risk 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
From the Publisher
From the Back Cover
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
About the Author
Paul Duvall is the CEO of Stelligent, a firm that helps clients create production-ready software every day. A featured speaker at many leading software conferences, he has worked in virtually every role on software projects: developer, project manager, architect, and tester. He is the principal author of Continuous Integration: Improving Software Quality and Reducing Risk (Addison-Wesley, 2007), a 2008 Jolt Award Winner. Paul contributed to the UML 2 Toolkit (Wiley, 2003), writes a series for IBM developerWorks called Automation for the people, and contributed a chapter to No Fluff Just Stuff Anthology: The 2007 Edition (Pragmatic Programmers, 2007). He is passionate about automating software development and release processes and actively blogs on IntegrateButton.com and TestEarly.com.
Stephen M. Matyas III is vice president of AutomateIT, a service branch of 5AM Solutions. He has a varied background in applied software engineering, with much of his professional, hands-on experience being in the areas of enterprise Java and custom software development and services.
Andrew Glover, president of Stelligent Incorporated, is a frequent speaker at conferences throughout North America, as well as author and coauthor of many books and online articles.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
It was tough to give it 4 stars, when it really deserves 5 for the quality of information. The reason I give it 4, is because things are repeated way too much. For example ("CI is great because you can do this, this, and this"), couple pages later ("CI is great because you can do "this", "this" and "this"). I found this a bit annoying being told the same thing again and again.
If this seems like a nice to have feature of your own development, but less of a core practice when compared to version control and comprehensive tests (both of which are requirements for doing CI), this book does a pretty good job of advocating CI as being just as important.
First, the book introduces the core practices of CI (regular builds, tests, and deployment), then goes on to demonstrate how it facilitates other, more advanced practices, which gain value when automated, such as enforcing code style, and recording code metrics.
It does not assume any particular platform, although most of the code uses Java and C# (and associated XML configuration). As a result, it will appeal most to those who want general guidance about why CI is a good idea, what to put under CI, how often to integrate, how long to allow the build to take, what to do if builds are too slow, etc. There's clearly no one-size-fits-all answer to this and this not a step-by-step tutorial book, so you'll need to adapt the code samples given in this book for your own ends.
Therefore, if you're completely new to the idea of CI, then maybe you might want to check out Mike Clark's Pragmatic Project Automation first, which covers a lot of the same ground as the first part of this book, but goes into a lot more detail about the mechanics of using Ant and JUnit with Cruise Control.
Apart from being more language agnostic, what takes this book beyond the Pragmatic tome is the second part, which demonstrates the more advanced processes that CI makes possible: including a chapter on how to integrate databases into CI, which touches on some cultural issues (e.g. the DBA being separate from the rest of the coding team) and providing sandboxes for each developer. Additionally, there's material on how to include reporting and analysis, e.g. code duplication, code coverage and static analysis tools such as Java's FindBugs.
It's also a quick and easy read (less than 300 pages), while still having a pretty wide purview. I don't think this is a subject that would benefit from an enormous tome, and you'll still come away with a much clearer idea of your project's automation and scheduling needs, although you might have to do a bit of digging in online documentation of the various tools mentioned in the book to find your exact solution.
The only bad thing I have to say about this book is that there are some very brief developer dialogues sprinkled throughout, used as examples to highlight suboptimal practices. As ever, these are cringe-inducing and artificial.
Out of the core agile practices of unit testing, version control, and project automation, the latter has the least amount of material available to read. Fortunately, this is a readable, persuasive and helpful book for curing the big bang integration blues.
Yes, this is what i have to say about this book. Absolute must! Even if you are not inclined towards CI (i am not sure why this can be the case, but lets say it is), even then you must read this book to broaden your vision and i bet you will start seeing the benefit by the time you finish reading this book.
Did i mention, it is a _must_ read?
"Continuous Integration - Improving Software Quality and Reducing Risk" describes this automation, covering everything from automated compilation through to automated deployment, covering topics such as automated testing, inspection etc along the way. It has a leaning towards Java environments, but also refers to tools for .Net (although it doesn't make explicit whether this means true "managed" .Net projects or whether it also includes unmanaged C++ projects written using Visual Studio .Net. It does seem that the .Net references normally relate to managed code, most likely produced with C#). Note that there is also an associated web-site containing related videos and other resources.
This book covers many of the typical questions that arise when automating build-related processes, including optimising the build, increasing the chances that if the build is going to fail it does so quickly, feedback methods etc. Interestingly, it also covers some team-dynamic/psychology stuff, which are things that we see in practice but you rarely read about.
In terms of intended audience, I would recommend this book to developers, testers and development managers. My own experience shows that developers can introduce these techniques themselves, in parallel with doing their allocated tasks, but things would happen quicker if management understood the benefits and allocated time and resources to put these practices in place at the beginning of projects. So, if you are a development/project manager, please do read this book (or even the similar, but shorter, Pragmatic book on the same subject). If you are a developer, the Pragmatic book is good, but I would really go for this one instead, even though it is longer. There is more information in this one, including an overview of various existing tools.
There are places where a bit more detail would have helped, particularly for environments other than Java and .Net. Some more detail on integrating with different version control systems would have been good too (the emphasis is on SubVersion, but suddenly switching to cvs in places). However, these are minor niggles that could easily be addressed on the related web-site. Of course, if details were included in the book for every common environment the book would get significantly longer, which would deter some people who should read it from doing so. So it probably has the balance about right for most people.
All-in-all, this is a very good book. I just wish I had written it first !
Most recent customer reviews
Lot's of good, objective views on tools and implementation designs too.