Here are 68 books that xUnit Test Patterns fans have personally recommended if you like
xUnit Test Patterns.
Shepherd is a community of 12,000+ authors and super readers sharing their favorite books with the world.
I’m a professional software developer for more than 22 years now. I’ve used many programming languages, platforms, frameworks, etc. throughout my career. However, the only constant for me personally was the practice of Test-Driven Development. I’ve never stopped learning about the principles and practices behind it, and it paid huge dividends throughout my career. I’m very humbled and grateful to be able to learn from all those amazing people over the years, that I decided to write a book on the topic. Giving back some of the knowledge that I gathered about TDD throughout 18+ years.
During the early years of my career as a software developer, I regularly developed very small programs that would exercise parts of the system that I was working on back then. I realized very quickly that those small programs would save me a lot of time figuring out whether the changes that I made would actually work or not. Until at some point a colleague mentioned the concept of Test-Driven Development. I first did some experimentation, dipping a toe into the water to feel the temperature. It wasn’t until the first time I picked up this book that I jumped right in. From then moment on, it all made sense. Although this book was published back in 2002, for me it still is the book when it comes to the subject of Test-Driven Development.
Quite simply, test-driven development is meant to eliminate fear in application development. While some fear is healthy (often viewed as a conscience that tells programmers to "be careful!"), the author believes that byproducts of fear include tentative, grumpy, and uncommunicative programmers who are unable to absorb constructive criticism. When programming teams buy into TDD, they immediately see positive results. They eliminate the fear involved in their jobs, and are better equipped to tackle the difficult challenges that face them. TDD eliminates tentative traits, it teaches programmers to communicate, and it encourages team members to seek out criticism However, even the…
I’m a professional software developer for more than 22 years now. I’ve used many programming languages, platforms, frameworks, etc. throughout my career. However, the only constant for me personally was the practice of Test-Driven Development. I’ve never stopped learning about the principles and practices behind it, and it paid huge dividends throughout my career. I’m very humbled and grateful to be able to learn from all those amazing people over the years, that I decided to write a book on the topic. Giving back some of the knowledge that I gathered about TDD throughout 18+ years.
I must admit that the first time I read this book, it completely didn’t resonate with me. Sure, I picked up a couple of very important concepts here and there. One of those concepts is the “Test Data Builder”. However, some of the techniques I completely rejected. It took me a couple of years to start opening up to the practices described in this book. After a second read, I came to the conclusion that this excellent work deserved more credit. That’s why I added it to this list. This book shaped my entire thinking around Outside-In TDD, which is a very important approach to guiding well-designed software systems.
"The authors of this book have led a revolution in the craft of programming by controlling the environment in which software grows." --Ward Cunningham
"At last, a book suffused with code that exposes the deep symbiosis between TDD and OOD. This one's a keeper." --Robert C. Martin
"If you want to be an expert in the state of the art in TDD, you need to understand the ideas in this book."--Michael Feathers
Test-Driven Development (TDD) is now an established technique for delivering better software faster. TDD is based on a simple idea: Write tests for your…
I’m a professional software developer for more than 22 years now. I’ve used many programming languages, platforms, frameworks, etc. throughout my career. However, the only constant for me personally was the practice of Test-Driven Development. I’ve never stopped learning about the principles and practices behind it, and it paid huge dividends throughout my career. I’m very humbled and grateful to be able to learn from all those amazing people over the years, that I decided to write a book on the topic. Giving back some of the knowledge that I gathered about TDD throughout 18+ years.
I was quite late in picking up this book after it got published in 2014. Turned out that this mistake was all mine. Although the book is very opinionated, this masterpiece is filled with many nuggets of wisdom when it comes to writing highly maintainable unit tests. There are lots of code examples to be found as well. The ideal book to read after Test-Driven Development By Example and Growing Object-Oriented Software, Guided By Tests.
This book details Jay Fields' strong opinions on the best way to test, while acknowledging alternative styles and various contexts in which tests are written. Whether you prefer Jay Fields' style or not, this book will help you write better Unit Tests.
From the Preface:
Over a dozen years ago I read Refactoring for the first time; it immediately became my bible. While Refactoring isn’t about testing, it explicitly states: If you want to refactor, the essential precondition is having solid tests. At that time, if Refactoring deemed it necessary, I unquestionably complied. That was the beginning of my quest…
I’m a professional software developer for more than 22 years now. I’ve used many programming languages, platforms, frameworks, etc. throughout my career. However, the only constant for me personally was the practice of Test-Driven Development. I’ve never stopped learning about the principles and practices behind it, and it paid huge dividends throughout my career. I’m very humbled and grateful to be able to learn from all those amazing people over the years, that I decided to write a book on the topic. Giving back some of the knowledge that I gathered about TDD throughout 18+ years.
This is the most recent book I'm recommending, and it’s also more than just a book on Test-Driven Development. I often proclaim that Test-Driven Development and software design are two sides of the same coin. One cannot separate one from the other. So learning about Test-Driven Development also means that one has to learn about software design principles. This book teaches both. The first part of the book is all about Test-Driven Development, while the remainder of the book also touches on object calisthenics, refactoring, code smells, design patterns, the S.O.L.I.D. principles, connascence, the four elements of simple design, and much more. Whether you’re new to programming software, or whether you’re a seasoned developer, there’s much to learn from this book.
Delve deep into the various technical practices, principles, and values of Agile.
Key Features
Discover the essence of Agile software development and the key principles of software design
Explore the fundamental practices of Agile working, including test-driven development (TDD), refactoring, pair programming, and continuous integration
Learn and apply the four elements of simple designBook Description
The number of popular technical practices has grown exponentially in the last few years. Learning the common fundamental software development practices can help you become a better programmer. This book uses the term Agile as a wide umbrella and covers Agile principles and practices, as…
I have been working with computers for decades now – having started with programmable handheld calculators and working my way up and down through mainframes, mini- and micro-computers. I always thought there is an art to writing software, and that good software can be read and admired. Maintainability, readability, and testability are some core needs for software, and after going through many programming paradigms, I feel that functional programming (FP) is the way to go – and several modern web frameworks agree. JavaScript (and now, TypeScript) are essential to web development, and I wanted to show how FP could be successfully used with those languages, and thus my book.
Of all the books I recommend, this is practically a sort of personal bible, which I very frequently consult.
This book doesn't just show you how to code; with realistic patterns and real-world examples, it's like having experienced mentors guiding your every keystroke. These patterns aren't just snippets; they're blueprints for building robust, flexible software.
I think the book is practically mandatory for all developers, novice or seasoned. It transformed how I approach problems, teaching me techniques I use daily in systems design and development.
Capturing a wealth of experience about the design of object-oriented software, four top-notch designers present a catalog of simple and succinct solutions to commonly occurring design problems. Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves.
The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the…
My passion for developing production-ready, cooperating microservices began in 2008 when I first started assisting customers in creating distributed systems—long before the term “microservices” was coined. During that time, I faced significant challenges, including grappling with the “Eight Fallacies of Distributed Computing”. Since then, I’ve dedicated most of my career to deepening my understanding of these complexities and finding ways to address them through robust architecture, design patterns, and the right tools.
No matter how advanced our tools for developing resilient and scalable microservices become, the million-dollar question remains: How do we effectively break up a monolith into microservices?
This book offers excellent guidance on this challenge. I found its starting point grounded in Domain-Driven Design and its concepts like Bounded Contexts and Aggregates particularly valuable. These concepts are key to mapping microservices to a real-world domain model. I also appreciate Sam’s advice, to begin with a few relatively large microservices aligned with Bounded Contexts and only break them into smaller services when there’s a clear business case for doing so.
How do you detangle a monolithic system and migrate it to a microservice architecture? How do you do it while maintaining business-as-usual? As a companion to Sam Newman's extremely popular Building Microservices, this new book details a proven method for transitioning an existing monolithic system to a microservice architecture.
With many illustrative examples, insightful migration patterns, and a bevy of practical advice to transition your monolith enterprise into a microservice operation, this practical guide covers multiple scenarios and strategies for a successful migration, from initial planning all the way through application and database decomposition. You'll learn several tried and tested…
Markus Gärtner works as Organizational Design Consultant, Certified Scrum Trainer, and Agile Coach for it-agile GmbH, Hamburg, Germany. Markus, author of ATDD by Example - A Practical Guide to Acceptance Test-Driven Development, a student of the work of Jerry Weinberg, received the Most Influential Agile Testing Professional Person Award in 2013 and contributes to the Softwerkskammer, the German Software Craft movement. Markus regularly presents at Agile and testing conferences all over the globe, as well as dedicating himself to writing about agile software development, software craft, and software testing, foremost in an Agile context.
While this book was still in the writing, Crispin and Gregory published draft chapters on the internet.
At the time, I read them, and managed to introduce many of the great insights into my own work. Even though I was working in a more traditional environment, the ideas from the two ladies inspired me on my journey to the agile methodologies.
I even managed to contribute some of my own real-world examples from my own experiences to their writings – and they decided to include some of them.
Te>Two of the industry's most experienced agile testing practitioners and consultants, Lisa Crispin and Janet Gregory, have teamed up to bring you the definitive answers to these questions and many others. In Agile Testing, Crispin and Gregory define agile testing and illustrate the tester's role with examples from real agile teams. They teach you how to use the agile testing quadrants to identify what testing is needed, who should do it, and what tools might help. The book chronicles an agile software development iteration from the viewpoint of a tester and explains the seven key success factors of agile testing.…
I’ve spent more than a decade working on infrastructure, from my early days at LinkedIn, where we had to do a massive DevOps transformation to save the company, to co-founding Gruntwork, where I had the opportunity to work with hundreds of companies on their software delivery practices. From all of this, I can say the following with certainty: the DevOps best practices that a handful of the top tech companies have figured out are not filtering down to the rest of the industry. This is making the entire software industry slower, less effective, and less secure—and I see it as my mission to fix that.
This is one of those books that changed how I thought about and approached software development. First, the book addressed the pain points that I had run into so often: the problems with infrequent, manual deployments, the outages caused by changing configuration rather than source code, the nightmare of merge conflicts that you get from long-lived feature branches, and so on.
Then, it showed how to flip the typical software development process on its head through CI / CD, changing the default from “our software is broken, and we need an integration and release process to get it working” to “our software is always working, and we can release it at any time.” Once I read it, I could never go back to the old way.
Getting software released to users is often a painful, risky, and time-consuming process.This groundbreaking new book sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers, and operations, delivery teams can get changes released in a matter of hours-sometimes even minutes-no matter what the size of a project or the complexity of its code base.
Jez Humble and David Farley begin by presenting the foundations of a rapid,…
Markus Gärtner works as Organizational Design Consultant, Certified Scrum Trainer, and Agile Coach for it-agile GmbH, Hamburg, Germany. Markus, author of ATDD by Example - A Practical Guide to Acceptance Test-Driven Development, a student of the work of Jerry Weinberg, received the Most Influential Agile Testing Professional Person Award in 2013 and contributes to the Softwerkskammer, the German Software Craft movement. Markus regularly presents at Agile and testing conferences all over the globe, as well as dedicating himself to writing about agile software development, software craft, and software testing, foremost in an Agile context.
The second book from Gregory and Crispin brought me up-to-date on the different trends in the Agile world, ten years after having delved into their first book.
How do you share the quality mindset in a DevOps culture? What about Design Thinking? With many more examples from the industry, the two authors made me curious about some of the things that I had ignored until I read their book.
Janet Gregory and Lisa Crispin pioneered the agile testing discipline with their previous work, Agile Testing. Now, in More Agile Testing, they reflect on all they've learned since. They address crucial emerging issues, share evolved agile practices, and cover key issues agile testers have asked to learn more about.
Packed with new examples from real teams, this insightful guide offers detailed information about adapting agile testing for your environment; learning from experience and continually improving your test processes; scaling agile testing across teams; and overcoming the pitfalls of automated testing. You'll find brand-new coverage of agile testing for the enterprise,…
Markus Gärtner works as Organizational Design Consultant, Certified Scrum Trainer, and Agile Coach for it-agile GmbH, Hamburg, Germany. Markus, author of ATDD by Example - A Practical Guide to Acceptance Test-Driven Development, a student of the work of Jerry Weinberg, received the Most Influential Agile Testing Professional Person Award in 2013 and contributes to the Softwerkskammer, the German Software Craft movement. Markus regularly presents at Agile and testing conferences all over the globe, as well as dedicating himself to writing about agile software development, software craft, and software testing, foremost in an Agile context.
“Good agile testing is good context-driven testing applied in an agile context.”
I recall reading through the authors’ lessons on software testing at about the same time I dived into more agile topics. Lessons Learned in Software Testing helped me keep the connection towards more traditional contexts – more so since I was still working in a more traditional context.
With their more than 100 lessons some of them applied to me, others did not. I am sure, other readers will find the same in their context.
Most companies developing software employ something they call "Agile." But there's widespread misunderstanding of what Agile is and how to use it. If you want to improve your software development team's agility, this comprehensive guidebook's clear, concrete, and detailed guidance explains what to do and why, and when to make trade-offs.
In this thorough update of the classic Agile how-to guide, James Shore provides no-nonsense advice on Agile adoption, planning, development, delivery, and management taken from over two decades of Agile experience. He brings the latest ideas from Extreme Programming, Scrum, Lean, DevOps, and more into a cohesive whole. Learn…
