Simply put: for professionals who are involved in the development of real-world Web applications using the ASP.NET platform, Kiessig’s book is a must-read. He has managed to compile many recipes to implement fast and scalable Web applications. The recipes range from consuming less bandwidth to configuring disk arrays, including recipes to control concurrency. What I most appreciate is the author’s attempt to explain the insights of almost every recipe. From reading numerous papers on optimizing Web applications for scalability, I had concluded that this was a kind of mystery; on the contrary, this book provides detailed explanations and examples for the techniques and their implications.
The book comprises 11 chapters, plus an introduction, an authorial biography, a glossary, and an index. Chapters 1, 2, and 10 are technology-agnostic, which makes them valuable for programmers who use technologies other than ASP.NET. Chapter 1, though lacking details, provides an overview of the many different places a Web application can be optimized for scalability. Chapter 2 advises readers on how to optimize client performance, which includes increasing browser caching, pre-caching, optimizing network utilization, arranging scripts for optimum performance, and dealing with images. Chapter 10 delves into how to devise and implement a distributed system from an infrastructure point of view; this includes advice on capacity planning, designing the network, disk arrays, implementing load balancers, and server monitors.
Chapters 3 to 9 focus on ASP.NET technologies. Chapter 3 reports on the many opportunities to cache data at all tiers of a Web application--for example, with a browser’s cache, cookies, view state, the Windows kernel cache, and the SQL Server cache. Chapter 4 discusses several tricks and tips that may help configure Internet Information Services (IIS) Version 7 so that it consumes less bandwidth and memory; these recipes are applicable to IIS Version 6, too. Chapter 5 deals with two topics that are quite independent from each other: first, it reports on how multithreading impacts scalability, with an emphasis on how and when to make asynchronous database calls to help threads work more efficiently; next, it reports on how to make session state more scalable. Chapter 6 advises on how to benefit from browser-specific optimizations and how to efficiently deal with images. Chapter 7 reports on hypertext transfer protocol (HTTP) modules and handlers, chapter 8 presents techniques for optimizing database access in a general setting, and chapter 9 focuses on optimizing online analytical processing (OLAP) databases.
The book concludes with Chapter 11, which is basically a checklist that includes a short summary of the recipes presented in the previous chapters.
In summary, this is a great book for many reasons: it is easy to understand, it is supported by lots of examples, and it includes plenty of useful advice. Its only weaknesses are chapters 7 and 8. Chapter 7 discusses topics that do not really relate to performance and scalability--for example, intercepting global events to write a log, page adapters, and uniform resource locator (URL) rewriting. Chapter 8 fails to deal with high-level database abstractions, such as DLINQ. Readers who are interested in more advanced topics should read Fritchey and Dam’s book [1], and readers who are interested in performance testing should read Meier et al.’s book [2]; both are excellent companions to Kiessig’s text.
