Browse Books

Reviewer: Marc Paquette

Small memory software deals exclusively with design patterns that limit the amount of memory used by a software system. As Noble and Weir describe, the motive for optimizing memory usage depends on the system to which these patterns are applied to. A programmer developing software for an inexpensive portable device with a fixed amount memory has an obvious need for such techniques. A large transaction processing system can also take advantage of these patterns to improve the system's capacity to process and store transactions. This book effectively makes use of the conventions used in describing patterns in software development that the "Gang of Four" [1] established. A software development pattern is the classification and description of an object-oriented solution that has proven to be effective. Following this convention, each pattern in the book is presented with a name, the problem it solves, the conditions under which programmers typically apply it, the forces that it resolves and exposes, rules for applying the pattern, and examples of its implementation, including source code examples in Java, C++, and, occasionally, Smalltalk. A good overview is provided in the introduction and appendix to help the reader choose an appropriate pattern. The appendix provides force details. A pattern's forces are especially relevant when designing a system in order to use as little memory as possible. There are important compromises in performance, power usage, reliability, and implementation costs to consider. Noble and Weir make a strong effort to present these forces, not only describing them in depth, but offering a convenient table of patterns and forces to make it easy to compare them. The book's patterns are organized into five major sections. Each section presents a set of related patterns. The first section presents patterns that manage memory for an entire system, including patterns to prevent system failure when memory allocation fails, and patterns to manage read-only memory. The patterns in the next section manage memory in secondary storage. These patterns solve problems for using, for example, disk or flash memory in concert with primary read/write memory. Examples include the packages, pattern, and the paging pattern (also known as virtual memory). Section 3 presents compression patterns. This section only describes three major types of compression techniques; going further would require several more books to cover this complex subject. The list of relevant references gives the reader more in-depth guidance. Section 4 offers patterns that reduce the amount of memory used in data structures. These patterns include tricks for sharing copies of the same data. The fifth section of patterns provides techniques for memory allocation schemes, including fixed allocation, reference counting, and automatic garbage collection. Again, this is a complex subject (perhaps even controversial), and deep discussion is beyond the scope of the book. Thankfully, again, the book's excellent list of references saves the day. Throughout the book, Noble and Weir refer to a fictional strap-it-on computer system to provide examples of how these patterns might be applied. They only give brief mentions of actual memory-constrained systems that use the same patterns. I would have preferred replacing all mention of the strap-it-on system with more in-depth descriptions of patterns implemented on actual systems. Still, this book is well organized, comprehensive, and clearly written. It offers good examples, has a good index, and fills out its subject matter with an extensive list of references. Noble and Weir take good advantage of design pattern conventions to present a complex, broad view of the subject. Online Computing Reviews Service