Poorly performing applications and systems cost companies millions of dollars every year in revenue losses, delays, damaged reputations, and ultimately missed business opportunities.

While many people treat performance engineering as an art rather than a science, this book tries to establish a formal methodology aimed at solving performance problems such as capacity planning and performance tuning. The reasons behind the use of the term “tries” will become evident later.

According to the author, the book targets readers involved in sizing, deploying, tuning, and maintaining enterprise applications. Unfortunately, the author assumes that the reader is familiar with queueing theory (and in particular with queueing networks) and skips many important details. Frankly speaking, I do not think the average system architect is familiar with queueing networks.

The author also states that students might benefit from reading this book. I have read the book twice; unfortunately, all I see for students is a set of examples and Excel charts. As far as I understand the book, there is no “modeling” part, which is, in my opinion, the most important part (once you know how to model a system, computing the average number of jobs in the system is not difficult).

The first chapter introduces basic topics, including closed queueing networks (the author models a three-tier system with them) and performance indicators (for example, average response time). The second chapter describes a few tools that can be used to extrapolate a number of metrics, such as input/output statistics (iostat), from the operating system (OS). This chapter would like to introduce the reader to modeling, but fails miserably. The author spends only three pages (including figures and tables) describing how best to model a system (neither Jackson networks nor mean value analysis are employed anywhere in the book). The rest of the chapter focuses on model calibration, introducing Little’s theorem; Java modeling tools (JMT), an open-source suite that can be used to model queues; and various screen shots (for example, Windows and vmstat).

The third chapter is a bit more interesting than the previous two, as it introduces a number of important metrics, including number of active users, number of concurrent users, and number of registered users. Unfortunately, it does not clearly explain how these affect the system’s behavior.

I was looking forward to reading chapter 4, “Servers, CPUs, and Other Building Blocks of Application Scalability,” but was ultimately disappointed. Unfortunately, it is nothing more than a collection of Excel charts and what-if analysis. While it is definitely interesting to see how the number of users affects the disk queue, no model is described. This is a pity. The results displayed in the charts have a mathematical foundation, but it has been omitted.

Chapters 5 and 6 quickly describe how to assess the overhead due to the OS and software. Chapter 7 briefly deals with virtualized environments (15 pages, including charts and tables, and in a large font). Chapter 8 describes how to analyze what-if scenarios, while chapter 9 concludes the book with models of different configurations (for example, remote users connecting to an application using a slow network).

To conclude, while the topic is very interesting, the author omits many important details, including how to model a system, how to estimate future resource consumption by forecasting user demand, and how to estimate the maximum capacity of a resource knowing only the current usage (for example, identifying when linear regression can be employed).