It is a scenario too familiar to the software industry: new software is delivered to customers and suddenly unforeseen and devastating bugs cause everything to crash.
Patterns for Performance and Operability is filled with practical, hands-on software development and testing techniques to ensure customers enjoy properly running software rather than complain about bugs and system crashes.
The book explores in-depth nonfunctional design and testing that too many software professionals overlook to their peril. It shows how to avoid a range of real world user problems, unexpected data permutations, and unforeseen input that lead to software failure. Designers, developers and testers can refer to the book's catalog of defensive software patterns to guarantee high-quality performance.
Review By: Alan Madick 12/08/2008
Functional requirements have been a mainstay in the world of application development since the first application was developed for use. It has been proven that the success of an application's deployment can be tied directly to the quality of and adherence to these functional requirements. For reasons unbeknownst to me, however, non-functional requirements (which include performance and operability) have always been the "black sheep" of the development lifecycles and are often overlooked during the project planning stage. Patterns for Performance and Operability was written to provide readers with an understanding of non-functional requirements which, while far less understood, are equally critical to the success of any enterprise system.
The book is written in an easy to read and logical format. The first chapter discusses a couple of case scenarios which provide examples of problems that are likely to occur in production environments if non-functional requirements are not covered in the system lifecycle. Subsequent to these case studies, the book proceeds with a discussion of project planning, performance and operability concepts, test planning and execution (as they relate specifically to non-functional requirements), deployment, operations monitoring, troubleshooting and crisis management, and common impediments to good design. It is obvious that the authors have "walked the walk" and had to endure sleepless nights trying to troubleshoot and manage problems in real production environments as their experience clearly shows throughout the book.
Beyond the logical, easy to read format, I particularly enjoyed the authors' use of tables, case studies, and diagrams. Being someone who benefits from visual clues, I found myself able to tie the concepts of the book together by referring to these items as I read through the chapters. I believe that the use of tables and diagrams will make this book one that is more likely to remain an engineer or testing resource and one that is more likely to be referenced time and time again.
The concepts and principles in this book will never be outdated. Regardless of the components that your application will use--be they Web-based, client-server, ASP or otherwise--the concepts related to non-functional requirements will continue to be relevant. Also, as users continue to rely more and more on these systems, the importance of including these requirements in every phase of the system lifecycle will only become greater over time. I recommend this book to anyone who has a responsibility and interest in improving the quality of enterprise software. Whether you are deploying your software internally at your own organization or externally for customers reading this book and implementing the principles (assuming this is not already being done) will undoubtedly improve the quality of your system and will lead to an improved computing experience for your end users.