Buy used:
$8.98
FREE delivery May 24 - 31. Details
Or fastest delivery May 20 - 22. Details
Used: Acceptable | Details
Condition: Used: Acceptable
Comment: Former library book; Readable copy. Pages may have considerable notes/highlighting. ~ ThriftBooks: Read More, Spend Less
Access codes and supplements are not guaranteed with used items.
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Something went wrong. Please try your request again later.

Quality Code: Software Testing Principles, Practices, and Patterns 1st Edition

3.2 3.2 out of 5 stars 10 ratings

Vance, Stephen
Read more Read less

Amazon First Reads | Editors' picks at exclusive prices

Editorial Reviews

From the Author

As I've coached software engineering teams on testing practices I've found that often the obstacle is not whether they believe they should test or whether they understand the concepts of testing, but the concrete understanding of what testable code looks like and knowledge of the implementation patterns of how to bring code under test.

Looking around, I realized that no one had written squarely on this topic. There are lots of great books by the likes of Bob Martin, Michael Feathers, Lasse Koskela, Kent Beck, Steve Freeman and Nat Pryce, Martin Fowler, Joshua Kierevsky, and others that address approaches to testing, the importance of testing, and so forth. In the process they show techniques for bringing code under test, but it's usually secondary to the points being made. The only exception to this is Michael Feathers' "Working Effectively with Legacy Code" but it has a very specific focus that necessarily limits the techniques discussed.

Many of the examples of the book are in Java, although overall I use a dozen or so languages for examples. This is largely an artifact of the language I was most immersed in when the seed of the idea was planted. There are many examples from JavaScript, including one of the worked example chapters. With a few exceptions that I tried to point out, almost all of the techniques can be applied in most languages with only a little adaptation, so if Java and JavaScript are not your primary tools, you should still be able to leverage the techniques.

Happy testing!

About the Author

Stephen Vance has been a professional software developer, consultant, manager, mentor, and instructor since 1992. He has practiced and taught code-level, automated testing techniques since 1997. He has worked across a broad range of industries for companies ranging from start-ups to Fortune 100 corporations. He has spoken at software conferences throughout the United States and Europe. Stephen lives with his wife near Boston, Massachusetts.

Product details

  • Publisher ‏ : ‎ Addison-Wesley; 1st edition (November 25, 2015)
  • Language ‏ : ‎ English
  • Paperback ‏ : ‎ 252 pages
  • ISBN-10 ‏ : ‎ 0321832981
  • ISBN-13 ‏ : ‎ 978-0321832986
  • Item Weight ‏ : ‎ 14.7 ounces
  • Dimensions ‏ : ‎ 7.25 x 0.5 x 9 inches
  • Customer Reviews:
    3.2 3.2 out of 5 stars 10 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.
Stephen Vance
Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Discover more of the author’s books, see similar authors, read author blogs and more

Customer reviews

3.2 out of 5 stars
3.2 out of 5
10 global ratings

Top reviews from the United States

Reviewed in the United States on September 28, 2017
A nice book for introduction in software testing but mostly teaching you techniques and not the craft of testing. It is also very sparsely written with big fonts and a lot of whitespace.
Reviewed in the United States on January 16, 2014
I am not really sure who this book is intended for.... It assumes you know the basics of testing so it's not for beginners, but there is very little information here for seasoned coders, though actually specifying the principles can be moderately helpful. From the description of the book I was really hoping for coverage of the full test "stack", unit, integration, performance etc, more specifically what domains you should cover and how you should create your testing strategies. Instead we get a bunch of useful, though pretty well-known unit test patterns. I guess if you have just started out writing tests and know the basics of the frameworks but not much else this book could be useful, but everyone else is probably better off with a more thorough treatment of the subject.
5 people found this helpful
Report
Reviewed in the United States on February 9, 2014
Part 1 was a good explanation of why testing is important and how generally you should write tests. It covers the topics such as what it takes to make good unit tests (think small decoupled code) and the idea of testing logic that is not part of the public interface (aka black box testing). However, the flow of the reading could have been a bit better as the paragraphs seem to go on and on.

Part 2 was where the rubber met the road. The author goes into each possible basic test type you could see in Java. Maybe it's because I usually write in Ruby, but I didn't really care much for this section and glossed over it.

One thing that was nice was the small coverage for Javascript. Since that's the new trend right now, I can see why the author included it. However, in the end, this book has an issue with focus. Is it for Java developers? Javascript developers? If for both, it could have done a better job by focusing on one or the other. Overall, Part 1 is great. If you're a Java dev that's interested in good testing practices, Part 2 should also meet your needs.
Reviewed in the United States on June 24, 2014
Having worked as a software developer, a QA manager, and an Agile development manager, I've often heard debate about whether or not developers should test their own code. Though certainly developers are expected to unit test, even in Agile environments, I've often seen the separation of roles between developers and testers. I've always been of the opinion that developers were quite capable of testing, and in fact, would ideally create automated tests to be run with each build and deployment.

One thing I really like about this book is that it teaches how to bake quality principals into the code and does not distinguish between a developer and a tester, but teaches these skills to the Agile team member. That being said, the reader should have coding skills in order to gain the benefits of the advice, and the book is more pertinent for the developer who wants to learn testing skills rather than the manual tester who wants to learn test automation skills.

The author does a great job of providing examples and patterns that will help the seasoned coder to thoroughly test and create a high quality application. In our modern world of continuous delivery, we must evaluate for test coverage and automation as a priority. This book will help the software development team learn the necessary skills to guarantee quality from the start.
2 people found this helpful
Report
Reviewed in the United States on August 7, 2014
I am definitely the target audience for this book - an experienced engineer who is sympathetic to Test-early and test-driven design. I am familiar with testing jargon such as "Sofware Developer in Test", "mocking", "seams", and such. But am also an engineer that works at a company that does not do significant testing, and as such when I try to use TDD concepts I find myself facing challenges such as determining what code to test first, and how to approach it.

If you fit that profile, this book is great. It discusses many mid-level concepts such as the nuts and bolts of how to take some specific systems and get them under tests. It talks in specifics about how to approach bringing legacy Javascript under test. It delves into more practical examples than many of the canonical texts in the field (such as "XUnit Test Patterns", "Refactoring", "Working Effectively with Legacy Code"), and so contains more "street smarts" than those books.

But I don't feel like this text is a good introduction to testing as a concept - it assumes a working knowledge of the field. It also won't serve as a good refernce to an expert test-driven development engineer. But if you're in the middle, and need a text to get you to a journeyman level - this is a fine place to look.
One person found this helpful
Report
Reviewed in the United States on March 26, 2014
"Quality Code - Software Testing Principles, Practices, and Patterns" book covers the different aspects of the software development lifecycle with focus on delivering quality products. Author Stephen discusses the practices for supporting software craftsmanship testing. He talks about design techniques like separating intent from implementation with simple code examples. Some of the testing principles discussed in the book include the following:

Verify Intent over Implementation
Prefer Minimal, Fresh, Transient Fixtures
Write Small Tests
Separate Your Concerns

Stephen also covered topics like testability patterns and testing parallelism techniques to verify conditions like race conditions or dead locks.

This is a great book to own for the software developers using agile methodologies and test driven design and development techniques in their projects. It contains several practical examples of best practices in delivering quality code.