So many books
SEPTEMBER/OCTOBER 2006 (Vol. 26, No. 5) pp. 82-83
0272-1732/06/$31.00 © 2006 IEEE

Published by the IEEE Computer Society
So many books
Richard Mateosian,
  Article Contents  
Download Citation
   
Download Content
 
PDFs Require Adobe Acrobat
 
I have covered many subjects in this column, but the majority of my reviews are of books in the fields of computer science, software, project management, and technical publication. In the last few months I have seen a large number of new works. Their subjects are interesting, and their production values make them a joy to look at and to hold.
Rather than choosing just a few of these books, I present a larger than usual selection—I wish I had time and space to review many more.
Many of these books are from small publishers. I'll let you draw your own conclusions about why that is.
Interface Oriented Design, Ken Pugh (Pragmatic Bookshelf, 2006, 232 pp., ISBN 0-9766940-5-0, http://www.pragmaticprogrammer.com, US$29.95)
Ken Pugh is an experienced software developer and an award-winning author. In this book, he treats an important design subject that many developers, even experienced ones, fail to appreciate.
Every introduction to object-oriented programming begins by explaining the key concepts of encapsulation, polymorphism, and inheritance. Pugh shows how to use interfaces to achieve true encapsulation and polymorphism. He explores the problems that inheritance presents and shows how interfaces can sometimes provide a better alternative to inheritance.
In Object-Oriented Software Construction (Prentice Hall, 1997), Bertrand Meyer formalized the idea of design by contract and specified certain implicit rules that all contracts should follow. An interface is a contract that provides explicit provisions about the preconditions for invoking a method and the conditions that should follow its return. Pugh applies design by contract throughout his book, but he focuses on only the main points, which he simplifies—in homage to Isaac Asimov's I, Robot (Gnome, 1950)—as the three laws of interfaces:

    1. An interface's implementation will do what its methods say it does.

    2. An interface implementation shall do no harm.

    3. If an implementation is unable to perform its responsibilities, it shall notify its caller.

Interface design is not an exact science. There are many ways to achieve the same basic functionality. Pugh discusses the issues and considerations that will help you make optimal designs. Many of these, such as loose coupling, are fundamental design principles. Others are specific to designing interfaces. Pugh illustrates his principles with several case studies, then looks back to summarize the patterns that they illustrate.
The chapter that I found most helpful is the one on interfaces and inheritance. Inheritance is a powerful means of developing a hierarchy of behaviors and implementations. But a hierarchy of behaviors can be inflexible and limiting. Interfaces focus on behaviors that may or may not be hierarchical. A hierarchy of implementations centralizes the code for common behaviors, but the delegation pattern can provide a way to achieve the same end for nonhierarchical interfaces.
This book will repay careful study. If you design computer programs, especially in object-oriented languages, you should read it.
Ajax Design Patterns—Creating Web 2.0 Sites with Programming and Usability Patterns, Michael Mahemoff (O'Reilly, 2006, 654 pp., ISBN 0-596-10180-5, http://www.oreilly.com, US$44.99)
Michael Mahemoff is a computer consultant whose academic research dealt with reusing designs in software and in user interfaces. Ajax (loosely an acronym for asynchronous JavaScript and XML) is a design pattern first described early in 2005 by Jesse James Garrett. It enables Web applications (for example, Google Maps) to provide highly interactive user interfaces within browsers, without using plug-ins.
Ajax is not a new technology. It is simply a new way of using old technologies to design applications that run in browsers and interact with remote servers. Mahemoff has compiled and described the patterns and best practices that have grown up around this new approach. Any Web application designer can benefit from reading his book.
Documenting APIs—Writing Developer Documentation for Java APIs and SDKs, James F. Bisso and Victoria Maki (Bitzone, 2006, 318 pp., ISBN 0-9630021-0-4, http://www.bitzone.com, US$49.95)
I have known and worked with the authors of this book for many years. Jim Bisso is a software engineer at Sun. Viki Maki is a technical writer and trainer. Both have taught classes in technical documentation.
The authors take you through all aspects of documenting Java APIs (application programming interfaces). They explain the different roles of different kinds of API documentation. For example, a programmer's guide and an API reference serve different purposes and complement each other.
Though the authors focus on Java, much in the book applies to API programming for other languages. Buying the book entitles you to access additional information from an associated Web site, including sample projects that the book refers to.
The authors write from the viewpoint of the person documenting the interfaces, but developers can get valuable insights from understanding that perspective. In many cases, developers provide the bulk of API documentation.
My connection with the authors makes me a biased reviewer, so I am hesitant to say too much about this book. I think I am safe, however, in saying that this is the only book on the subject. If you are involved in API documentation, you should definitely read it.
Communicating Design—Developing Web Site Documentation for Design and Planning, Dan M. Brown (New Riders, 2006, 368 pp., ISBN 0-321-39235-3, http://www.newriders.com, US$39.99)
Dan Brown, a Web consultant who specializes in information architecture and user experience, has written an unusual and valuable book. It is not about the mechanics of designing and implementing Web sites. Rather, it describes the artifacts that support clear communication among the designers and between the designers and their clients. Wireframes, site maps, flow charts, content inventories, personas, and other artifacts (known collectively as "the deliverables") provide the basis for this communication.
The deliverables are independent of the design and development methodologies you choose to use. Using definitions, explanations, and clear pictures and diagrams, Brown shows how to produce and use these artifacts. If you are buying or selling Web sites, you should read this book.
CSS—The Missing Manual, David Sawyer McFarland (Pogue PRESS, 2006, 494 pp., ISBN 0-596-52687-3, http://www.missingmanuals.com, US$34.99)
David Sawyer McFarland is an author, a teacher, and a webmaster. He has designed many Web sites. Cascading style sheets (CSS) is a language that enables Web designers to apply global styles to the raw HTML they use to encode the content of Web pages.
When browsers and Web sites first became popular in the early 1990s, designers were forced to apply font size, color, and other elements of appearance directly to each HTML element (heading, paragraph, and so forth) that they created. There was no mechanism to ensure that every first-level heading on a given page, let alone the whole Web site, had the same appearance. Furthermore, HTML provided only a limited number of ways to control appearance. Sophisticated visual designs required cumbersome misuse of HTML elements (for example, tables).
Designers soon recognized these defects, and CSS was born. But HTML was evolving rapidly, and CSS had a late start. It was not until recently that we had a version of CSS that designers could use effectively with their designs.
Using CSS is relatively simple, but it requires looking at design in a different way. McFarland explains this viewpoint, then goes on to show how to use each feature of CSS. He also starts with common design problems (for example, styling tables or forms) and shows how to use CSS to solve them.
The Missing Manual book series fills the need for user-centered documentation for many underdocumented products. This book accomplishes this task for CSS.
Secrets of RSS, Steven Holzner (Peachpit, 2006, 344 pp., ISBN 0-321-42622-3, http://www.peachpit.com, US$24.99)
Steve Holzner is a prolific author of books about XML and related topics.
RSS (really simple syndication) is, as the name suggests, a system for syndicating content. That is, it lets publishers make content available in an XML format called an RSS feed. It enables subscribers to aggregate content into personal collections and read that content using a browser. Many Web logs use RSS feeds to distribute content.
Following the excellent style of many books from this publisher, Holzner provides profusely illustrated step-by-step instructions for producing and consuming RSS feeds.
If your only interest in RSS is to be a subscriber, this book is more than you need. If you wish to publish, however, this book provides a clear view of everything you need to do.
.NET Internationalization—The Developer's Guide to Building Global Windows and Web Applications, Guy Smith-Ferrier (Addison-Wesley, 2007, 670 pp., ISBN 0-321-34138-4, http://www.awprofessional.com, US$49.99)
Internationalization is the process of preparing software to be easily translated (localized) for users who expect different languages, date formats, and other cultural conventions.
Guy Smith-Ferrier is a developer who specializes in internationalization. His book focuses on how to internationalize Windows Forms, ASP.NET applications, and other programs running in the .NET environment.
Internationalization is not conceptually difficult, but it requires building and using a large and complex infrastructure. Fortunately for .NET developers, .NET includes such an infrastructure, so you don't have to build your own. This book teaches you how to use that infrastructure. If you develop applications in a .NET environment, you will sooner or later need to understand how it supports internationalization. This book is the place to start.