Continuous Integration: Improving Software Quality and Re... and over one million other books are available for Amazon Kindle. Learn more
CDN$ 39.68
  • List Price: CDN$ 62.99
  • You Save: CDN$ 23.31 (37%)
Usually ships within 3 to 6 weeks.
Ships from and sold by Amazon.ca.
Gift-wrap available.
Quantity:1
Add to Cart
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Continuous Integration: Improving Software Quality and Reducing Risk Paperback – Jun 29 2007


Amazon Price New from Used from
Kindle Edition
"Please retry"
Paperback
"Please retry"
CDN$ 39.68
CDN$ 35.00 CDN$ 31.97

Join Amazon Student in Canada



Frequently Bought Together

Continuous Integration: Improving Software Quality and Reducing Risk + Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation + Test Driven Development: By Example
Price For All Three: CDN$ 110.22

Some of these items ship sooner than the others. Show details


Customers Who Bought This Item Also Bought

NO_CONTENT_IN_FEATURE

Product Details

  • Paperback: 336 pages
  • Publisher: Addison-Wesley Professional; 1 edition (June 29 2007)
  • Language: English
  • ISBN-10: 9780321336385
  • ISBN-13: 978-0321336385
  • ASIN: 0321336380
  • Product Dimensions: 23.2 x 17.7 x 1.8 cm
  • Shipping Weight: 499 g
  • Average Customer Review: 3.5 out of 5 stars  See all reviews (2 customer reviews)
  • Amazon Bestsellers Rank: #83,825 in Books (See Top 100 in Books)
  • See Complete Table of Contents


Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index
Search inside this book:

Customer Reviews

3.5 out of 5 stars
5 star
1
4 star
0
3 star
0
2 star
1
1 star
0
See both customer reviews
Share your thoughts with other customers

Most helpful customer reviews

Format: Paperback
This book is a valuable resource for anyone wanting to learn about the the fundamentals of continuous integration (CI). I've suggested to a large number of project teams which are in the process of adopting agile software development strategies, not that CI is just for agile mind you.
Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again.
1 of 3 people found the following review helpful By Dale Fukami on June 22 2009
Format: Paperback
I found the content in this book very repetitive and I think the whole thing could have been done at about 10% of the actual size. All in all I didn't think it added enough value to be worth the purchase. Read a few blogs about continuous integration servers instead.
Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again.

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 24 reviews
20 of 20 people found the following review helpful
Covers all the major deployment and automation issues Aug. 11 2007
By Thing with a hook - Published on Amazon.com
Format: Paperback
Continuous Integration refers to the practice of automating the build, testing and deployment of your software, so that producing a finished executable (and the related artifacts) can be done at the touch of a button, and is ideally carried out several times a day.

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.
11 of 11 people found the following review helpful
The Power of Feedback Sept. 28 2007
By Steve Berczuk - Published on Amazon.com
Format: Paperback
This book is an excellent overview of why Continuous Integration is important and about more than just compiling frequently. The book helps you to understand why to do CI, what you can do beyond building, and how to do it. In addition to general principles, the book points you to some excellent tools and resources. This book is an excellent companion to Software Configuration Management Patterns: Effective Teamwork, Practical Integration; it provides teriffic information that support the build patterns in that book. You might already know some of the information in this book, but it is worth buying if you need to encourge CI in your organization for the clear discussion of why CI matters and the for the detailed advice on how to implement it.
8 of 8 people found the following review helpful
A must read book about Continuous Integration!!! July 25 2007
By Jose Papo - Published on Amazon.com
Format: Paperback
This book is a must read for everyone delving into the practice of Continuous Integration. In my opinion, Continuous Integration is one of the most important practices to really achieve agility and to mitigate risks related to architecture and software integration.

The book contains more than 40 practices related to this important subject. For me, an experienced software engineer who already uses and knows a lot of CI tools, the best chapters are those which illuminate how to do Continuous Database Integration (Chapter 5), Continuous Testing (Chapter 6) and Continuous Inspection (Chapter 7).

Another great plus of this book is Appendix B on how to evaluate CI Tools. It gives a lot of hints to choose the right CI tool for your project or company.

Even if you are an experienced CI practitioner this book is a welcome addition. It shows why each practice is important and what are the benefits to use it on a SW development project.

If you are a beginner or intermediate practitioner in the Continuous Integration World this book is a must have. You will receive a lot of wisdom collected by the authors during their careers.

If you don't know what is Continuous Integration read the great article by Martin Fowler.

Spare you a lot of integration and software quality headaches reading this excellent book!
6 of 6 people found the following review helpful
Averagely good Aug. 18 2011
By NDev789 - Published on Amazon.com
Format: Paperback
The content of the book is good, All the theory of continous integration is covered.
The inspiration of the writer is great, but there is "so much, so much" repetition.
I sincerly think that, when aggregated the book would take only 40 pages.
6 of 6 people found the following review helpful
A good book on automating processes related to software development Feb. 15 2009
By J. S. Hardman - Published on Amazon.com
Format: Paperback
Software development is (normally) about automating tasks for other people, allowing clients to be more productive at what they do and allowing them to be more reliable in what they do. Automation reduces risk by reducing scope for manual error, particularly for repetitive and mundane tasks. What software developers have often not been so good at is automating the repetitive tasks that they do themselves to improve their own performance and reliability. Whether this is their own decision or because management don't allocate time or resources to do this automation varies from site to site. The evidence is clear though, even from my own experience, that sites where automation is used properly are far more productive, produce more reliable systems and are more fun places to work. I've worked places where this has been done well, I've also worked places where automation has never even been considered. In those latter cases I've done my best to introduce it, usually in incremental steps, with projects becoming far more efficient and reliable as a result. Just this week, whilst automating the building of existing systems for a client, I identified five projects developed by the client that couldn't be built from what was in version control - that alone is evidence that automation is required and, for this client, long overdue.

"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 !

Product Images from Customers

Search


Feedback