Books

This section contains capsule reviews of various books I have recently read, or have read in the past and still consider important today. Read the reviews, and click the links if you want to read what others also think about these books.

Programming the Mobile Web
There is a reason I've never wanted to write a technology-oriented book—unless you are writing about core foundational concepts, they have a very short shelf life in a rapidly evolving landscape. (The books I write have nothing to do with technology and will hopefully be useful for decades.) And that's the problem here. Although this book was published in 2010, I read it in 2012. Folks, two years is an eternity in the mobile landscape. We might as well be studying how Paleolithic humans constructed awls out of bone. Wireless Access Protocol (WAP), Wireless Markup Language (WML), and XHTML Mobile Profile (XHTML MP) were useful with keypad-based feature phones in the early part of this century, but modern iPhones, Android phones, etc. have all but relegated that technology and information to the heap of technical debt. That's not to say there isn't some good info in this book—there is. But the catch is, you have to know which bits to discard and which are still applicable. If you aren't intimately involved in this stuff on a weekly or daily basis, you may find yourself latching on to things from a begone era. If you are going to read mobile development books like this one, make sure it was recently published and read carefully.

Programming HTML5 Applications
Typically, the term 'HTML5' encompasses much more than strictly markup. It's commonly a term used to describe a family of technologies for building modern, mobile web sites and applications, including CSS3, JavaScript, ARIA, Local Storage, IndexedDB, Application Cache, Canvas, WebGL, Web Fonts, etc. This book takes the shotgun approach, covering many of these technologies, including some advanced JavaScript concepts (non-blocking I/O, Callbacks, Closures, Prototypes, Currying), Local Storage objects and methods, File objects, manifest files for offline support, and even increasingly useful specifications such as Web Workers and Web Sockets. You won't get a lot of depth on any of these topics here, but there is good overview material that will get you started creating HTML5-based apps quickly. It's a good all-in-one primer for those new to these concepts.

Pro jQuery Mobile
Now this is more like it. While the O'Reilly jQuery Mobile book disappointed (see my review below), due to its straightforward re-hash of the jQuery Mobile online documentation, here author Brad Broulik adds value to that documentation, extending it with more info, more examples, and a great diagram of the jQuery Mobile event model that is worth the price of admission alone. Once you read the jQuery Mobile online docs, this is the book you need to get.

jQuery Mobile
I was hoping that this book would add additional value to the jQuery Mobile online docs—it doesn't. In fact, as far as I could tell it's simply a re-hash of the online documentation. Buyer beware. But if you're the type who likes a hard-copy of things for highlighting, adding notes, etc. then you can pony up the cash for this book. I'll stick with the online docs—which I printed out.

jQuery Cookbook: Solutions & Examples for jQuery Developers
I needed an intermediate to advanced book that covered the jQuery JavaScript library for someone who was already familiar with other JavaScript libraries (YUI, Dojo, MooTools). This book fit that need exactly. A quick ramp up on jQuery syntax at the beginning, then right into solutions for common operations, performance tuning, jQuery UI, themes, enhancements and extensions. The book concludes with sections on using jQuery in large projects, using the QUnit test framework, and one of the best set of examples for using Ajax with JSON and JSONP that I've seen. Two weeks and 500 pages later, I'm at the advanced jQuery level. Thanks O'Reilly.

Masterminds of Programming
This book provides an interview format where the author (interviewer) asks the same questions (for the most part) to the creators of popular programming languages (C++, Python, FORTRAN, BASIC, Haskell, UML, Postscript, etc). This format allows the reader to compare and contrast the thought processes, perspectives, and beliefs among the various creators. In that vein, it really succeeds, and you'll no doubt notice many more similarities than differences. But when there are differences, they are vast and evident in the resulting language (for example, strict typing versus loose typing, or the design of garbage collectors and extension mechanisms). At times, the book gets very technical, but is very educational in that respect. Recommended for serious students of computing history and programming language theory.

97 Things Every Programmer Should Know
I read this book because, well, I wanted to see if I knew 97 things that 73 other programmers thought I should know. Luckily, after over 20 years of software development experience, there were no surprises on my part. However, for those just starting out in programming, this would be a valuable read, just to gain a cursory glance at the topics you should become familiar with. For experienced programmers, check it out if you want to satisfy your curiosity. Hopefully, you won't be surprised.

JavaScript: The Good Parts
Someone once said that JavaScript is like a scalpel—in the wrong hands it's dangerous, but in the hands of a surgeon, it provides incredible power. Here, author Douglas Crockford continues his decade-long evangelism of the world's most popular web-based language and shows you how to avoid cutting yourself while illustrating the adeptness of the language. Crockford deconstructs the language into the bad parts that you should avoid (with, eval, continue, new, void, etc.) and the good parts to embrace in order to create scalable, secure, enterprise-class code. After you've read a good intro book on JavaScript, this should be your next stop.

Object-Oriented JavaScript: Create scalable, reusable high-quality JavaScript applications, and libraries
I bought this book on the promise of its subtitle—specifically, that it would provide useful information regarding building a robust, custom JavaScript library for an enterprise. I was hoping that it would provide an ongoing example library that would be built up over the course of the book. No such luck. But, that doesn't mean it isn't a good book—just that the subtitle may be a little misleading. Stefanov does a good job of describing important JavaScript concepts such as prototype chaining, as well as useful coding and design patterns. A good solid book.

Pro JavaScript Techniques
Let's get this straight right away: the author is John Resig, the creator of the jQuery library, so obviously this guy knows what he is talking about. And just like jQuery, Resig presents a solid base by describing how to write reusable, unobtrusive, object-oriented JavaScript code. Then, he gets right to it by providing chapter after chapter of real-world examples of how to build useful stuff from this base. While he doesn't use jQuery in his code examples, per se, along the way you will learn how and why jQuery was constructed. Lots of good stuff to learn here that you can directly apply to your own projects, no matter what library (if any) that you use.

Pro JavaScript Design Patterns
Let me just say this up front—this book contains some advanced JavaScript techniques and code, and is not for the beginning or even intermediate JavaScript programmer. Even advanced practitioners may want to go back through for a second reading to ensure that all the concepts within are fully understood, especially when and how to use these patterns, as well as the advantages and disadvantages of each in context of the JavaScript implementations. Here we have two advanced authors, one from Google (Dustin Diaz), the other from Yahoo! (Ross Harmes), who have extensive experience building large-scale JavaScript-based API systems. They present 12 design pattern implementations in JavaScript, with examples of how each could be used, as well as the important core concepts of interfaces, encapsulation, information hiding, inheritance and chaining. Even if you only come away from the book learning and implementing one of the patterns or concepts in your code, it will help make the code you write more scalable, extensible, and longer lasting.

Web Accessibility: Web Standards and Regulatory Compliance
If you're looking for the guide to web accessibility, then (as of this writing) this is the bible of it. However, at 600+ pages of dense material, it's a slog to get through. However, persistent readers will be rewarded with the knowledge of the entire landscape of web accessibility, from how to make HTML, CSS, JavaScript, Flash, and PDFs accessible, to the inner reasonings behind the WCAG and Section 508. And, if you need to know how to make your site conform to the accessible laws and guidelines of the United States, Australia, Italy, the European Union, etc. or what the Flanders Plan for Accessible Websites or the what the Japanese JIS X 8341-3 Standard is all about, then this is the book for you.

Web Standards Creativity
I bought this book used for $2 and it's a good thing I did that, since almost all of the chapters are simply rehashes of previous material posted on the web. The book is divided into ten chapters, each one covering a particular topic and presented via a web standards-based project. And there are some heavy hitters authoring the chapters, including Andy Clarke, Cameron Adams, Derek Featherstone, etc. The real jewel here is Cameron Adam's chapter, "Creating Dynamic Interfaces Using JavaScript". There's some excellent techniques and lessons there that can be applied well beyond the described project. However, unless you want to pay for glossy paper and color screenshots, I would advise passing on this book (unless you can get it for less than $5), since you can find all of this material via simple Google searches or on the authors' websites.

Practical JavaScript, DOM Scripting, and Ajax Projects
This book combines a look at some of the most popular JavaScript frameworks available at time of print (Dojo, YUI, Rico, MochiKit, Prototype, and MooTools) with a project-based focus. For each chapter, the author selects a framework (such as Dojo) and uses that framework to build a project (such as a Drag and Drop Shopping Cart). This framework/project combo works well to give the reader familiarity with a wide range of frameworks and framework coding styles in the context of building real-world components. He also shows you how to build your own framework. The one issue that kept nagging me as I read through the book is the author's frequent use of obtrusive JavaScript code in the projects, in light of the fact that he spends an entire chapter up front discussing JavaScript best practices, including the use of unobtrusive coding techniques. If you can live with that, then this book presents a brief look at various JavaScript frameworks effectively. Just don't expect to learn any one particular framework in-depth from this book.

Pro JavaScript Techniques
If you are ready to move beyond inline or procedural JavaScript code, then this book should be first on your reading list. Here, you'll learn how to write reusable, object-oriented, unobtrusive, namespaced JavaScript that you can package into your own libraries for distribution and deployment. In essence, properly engineered JavaScript which is scalable and extensible. Your path to JavaScript jedi starts here.

Dreaming in Code
This book is paradoxically similar to the content it covers—and therein lies the problem. Dreaming in Code follows (for a three year period) the genesis and subsequent never-ending development of the open-source Chandler personal information manager (PIM) project. As the book relates the meandering development process, much like Lawrence trekking through Arabia, so too does the actual chapter by chapter account. Just as you are settling in as an invisible listener at design meetings, suddenly you are thrust into a chapter-long recantation of some particular aspect of historical software engineering design. I'm sure this was done in order to appeal to the luddite-fringe in the book crowd, but to seasoned veterans this is just plain frustrating. Sort of like sitting in your college calculus class and then suddenly having the teacher talk about the basics of addition. Which ties me to the problem with the book. If you are going to tout the book as the next generation successor to Soul of a New Machine, at least follow the phenomenal lead set by Mr. Kidder and tell the story about the people behind the machine—that's what sells and lasts the test of time. Technology comes and goes but it's the story of people which remain etched in time. To paraphrase, sorry but Dreaming in Code, you are no Soul of a New Machine. BTW, the end story told on the last two pages is priceless.

GreaseMonkey Hacks
There are three things that are really good about this book: 1) it really opens your eyes to the fact that the web page designer/developer has absolutely no final control over the page layout, presentation or behavior, 2) it presents a good feel for the range of things you can do with JavaScript to alter a web page or bend it to your will, and 3) the source code, which is printed for each hack, provides some of the best study material in coding style, best practices, etc. Highly recommended for intermediate to advanced JavaScripters. Heck, it's probably even good for beginners, since this type of stuff might get someone really interested in programming by sticking their toe in the water.

Beginning GIMP
Sooner or later you eventually learn that you need some basic proficiency with a graphics tool if you are going to play in this web-based world. Whether compressing images for optimal appearance versus file size, correcting red eye on family pictures, or constructing a collage of screenshots, you need to know the basics of image editing, resizing, cropping, etc. And you need to learn about layers. Layers will save you. Layers will set you free. So, I decided that after using PaintShop Pro for a decade, it was time to learn something that was ubiquitous across platforms, something that would last, ala Emacs for images. For better or worse, I chose the open-source GIMP program. And there are things you can do with GIMP that you can do with few other graphics software, such as program it with the built-in Python and Lisp languages. This book lives up to its subtitle: From Novice to Professional. While I may not be a professional after reading through the entire book, I am certainly a novice no longer. Recommended.

Founders at Work: Stories of Startups' Early Days
After reading the classic Programmers at Work (see below) back in the 1980s, then re-reading it again last year, I was a little disappointed with Founders at Work. The book has the same interview format as Programmers at Work, this time mainly with web startup founders from the 1995-2005 period. There is some overlap with similar individuals interviewed in Programmers at Work, such as Dan Bricklin, Steve Wozniak, and Mitch Kapor. But mainly, you'll read about the guys and gals behind PayPal, Blogger, Yahoo, craigslist, Flickr, del.icio.us, etc. I was hoping for the same level of storytelling from the individuals interviewed—however, this time I found the stories to be flat, and uninteresting after awhile. This may just be an individual preference and bias, since many readers of this book won't have been influenced by Programmers at Work. I would still suggest reading this one, but only after you've read Programmers at Work.

Programmers at Work: Interviews With 19 Programmers Who Shaped the Computer Industry
When Susan Lammers wrote this book back in 1986, the interviews with the programmers within gave us some good insight into how these guys (sorry, no gals) thought, created, and executed their visions. Today, these interviews serve as a tapestry of the history of computing. It's still interesting to read about the early days of Microsoft with Bill Gates, to listen to Dan Bricklin (VisiCalc) about the genesis of the modern day spreadsheet, to understand the vision Mitch Kapor (Lotus 1-2-3) had about extending the ideas that VisiCalc started, as well as from the man who actually programmed Lotus 1-2-3 (Jonathan Sacks). You'll also read about the people behind Multics, dBase, CP/M, Digital Research, Adobe, the Apple II and Mac, etc. Again, it's the storytelling of the people involved that elevates this book, not necessarily the technology. A classic book with the passage of time.

Hackers: Heroes of the Computer Revolution
Let's get this out of the way up front—the term "hackers" here refers to the original ideology of the word from the earlier days of computing, when hackers blazed the trail of our modern hardware and software systems. These are not the modern day denizen hackers of destructive, malicious infamy. Based on this understanding, this book should be required reading for anyone connected with the computing profession. It serves as a rich history of the genesis of modern day computing, from the earliest days at MIT, the birth of languages such as Lisp and BASIC, the origins of modern video games from Space War and Colossal Cave, to the natural evolution of microcomputing. Steven Levy shows us how a historical book about an industry should be written. It contains an unfolding, interrelated emotional story of people and technology. There are moments of wonder, awe, tenacity, pain, suffering, hope, idealism, and eventually, money, capitalism, and greed. Even at 450+ pages, this is one book you'll read through quickly. After reading this, you'll want to fire up Emacs, dust off Space War, and find out just how powerful this Lisp language from 1959 still really is ;-)

DOM Scripting: Web Design with JavaScript and the Document Object Model
JavaScript is like a scalpel—in the wrong hands, it can lead to disaster; in the hands of a skilled surgeon, it is a powerful tool. In Jeremy Keith's DOM Scripting, the guiding principle throughout is to turn you into that surgeon. The book opens by putting JavaScript into historical perspective, then follows that with the basics of the JavaScript language and the Document Object Model (DOM). From those basics, Keith layers and weaves best practices such as standards support, progressive enhancement, graceful degradation, and accessibility, all while slowly building components that reach a final crescendo in a complete website example. (Here's a hint: if your web pages have any in-line JavaScript code or handlers such as <body onload>, you're doing things wrong.) If you're looking for in-depth Ajax material here, look elsewhere. This book is all about doing JavaScript correctly—so you won't cut yourself later.

Building Accessible Websites
Written in 2002, this book is still considered the gold standard in web accessibility. I have no idea why. What Joe Clark has accomplished here is to spread about 20 pages of good accessibility information across a 400 page miasma. Most web designers don't care about the history of captioning and transcription systems--we just want the facts, man. What should we do, and what should we avoid. Best practices. Etc. That info is in here, but you have to cut a swath through the verbosity to find much of it. Or just read the last page of each chapter, which summarizes the previous 40-odd pages in six or less sentences. Save yourself the price of the book and scan through the entire text of the book online. In the end, Building Accessible Websites is an inaccessible read.

The Zen of CSS Design
Since I'm a frequent visitor to the excellent CSS Zen Garden web site, I purchased this book hoping that it would enlighten me regarding the technical implementation of some of the more advanced CSS designs. Unfortunately, I think the book just misses the mark. What you get is a brief six page explanation of a particular design concept for each of the 36 included designs. This is all good, but I was hoping to see at least a few of the very advanced designs completely dissected in explanation, from beginning of the source to the end. Intermediate CSS coders will undoubtedly pick up a useful technique or two. Still, it's a good book that could have been great.

Web Standards Solutions: The Markup and Style Handbook
Noted web standards guru Dan Cederholm (of SimpleBits fame) presents sixteen chapters devoted to the effective and optimal use of XHTML markup followed by advanced CSS techniques layered upon that markup. While much of this information has been covered before and will be familiar to intermediate and advanced XHTML coders, several of the CSS chapters are real eye-openers, even for advanced technicians. For example, in Chapter 11: Print Styles, Cederholm discusses an extremely effective technique for allowing the user to switch between alternative layouts of your page (two-column, three-column) without the need for a round-trip to the server. And Chapter 15: Styling <body> sounds innocent enough, but presents a technique that allows the developer to provide some basic Content Management System (CMS) functionality as applied to web templating. It's a short book (238 pages), and quick read, but may prove indispensible from a design, productivity, and business perspective. Highly recommended.

Designing with Web Standards
Forward-compatibility. Reduced site maintenance. Increased extensibility. More users. And big cost savings. That's what this book is about. Jeffrey Zeldman (of the The Daily Report) leads readers through the why's and hows of building web sites using the established standards of Structure (XHTML), Presentation (CSS), and Behavior (ECMAScript, DOM). Since most web site decision-makers don't yet grasp the significance and business reasons for moving to a pure, standards-based design, Zeldman spends the first 100 pages giving them no room for arguing against this approach (ESPN got the message--and saved tens of millions of dollars by converting their 1 billion hits per month site). The remainder of the book is spent in the trenches, providing exacting detail about how to upgrade existing sites or build new ones around standards. It doesn't hurt that Zeldman's humor and light writing style will speed you through this book. It may be the fastest read of any technical book to date--and that would be one of Zeldman's points.

The Design of Sites
Patterns, Principles, and Processes for Crafting a Customer-Centered Web Experience
While there are many books on the market that discuss patterns related to programming, architectural elements, etc., this is the first book I've seen that focuses on web patterns at the user interface level. The book is essentially an indexed, cross-referenced, best practices guide to building web pages that attract and keep customers. Or at least keep you from pissing them off. The authors have collected and summarized a great deal of HCI research (all listed in the resources section of the appendix) on web usability, so none of this stuff is made up--it's all based on time-proven, tested, and verified data about how people actually use the Internet (e.g., see Amazon, Yahoo!, Google, et. al.). A few of the patterns are no longer considered best practices, due to evolving standards (e.g., CSS) and increasing browser standards support. This is a very handy reference book, especially for an in-depth UI checklist.

HTML Utopia: Designing Without Tables Using CSS
I had high hopes for this book. After finishing Eric Meyer's latest CSS book (see below), I was ready for something completely dedicated to teaching me everything I needed to know about creating a site without using a single table tag for layout. Although the book does explain how to do this, I was still disappointed. After a brief introduction about CSS (yet again), section two of the book explains how to create layouts without using tables. In all, seventy pages of 500 are centered on this topic. Half the book is a CSS reference. The other sections talk about fonts, colors, etc. Clearly, the book is mis-titled. This remains a good book for someone new to CSS, so they can avoid bad habits from the start. However, I would recommend Eric Meyer's book for advanced CSS users.

Eric Meyer on CSS: Mastering the Language of Web Design
This is an excellent book for progressing from using style sheets for specifying only fonts and colors to building entire sites driven by CSS layout rendering--it is not a reference book. The author (who, incidentally led the W3C effort to define the CSS2 Recommendation) presents thirteen different real-world types of projects to teach and explain the power of CSS, ranging from conversion of existing pages and creation of menuing systems, to multicolumn layout. A short book that will make big changes in the way you build web sites.

CodeNotes for Web-Based UI
The stated purpose of the CodeNotes series of books is to get a developer up to speed on a particular technology or topic as fast as possible. This edition does a fairly good job of meeting this goal--it won't make you an expert in web-based user interface design, but after reading through its 200 pages, you'll know a lot more than someone with no experience in this area. The book does a very good job of introducing a concept and then jumping right into the areas which present typical implementation decisions/challenges for the developer. For example, the chapter on JavaScript gives a brief overview of the object-oriented constructs of the language, and then dives right into JavaScript's Regular Expressions syntax and its application in building client-side form validation handlers--one of the most typical uses of JavaScript. Likewise, the chapter on XML/XSLT moves quickly into templates, matching, flow control, and how to use this technology to build web pages which support all user agents. Other chapters similarly cover user interface design theory, DHTML, DOM and CSS.

The Design of Everyday Things
This is a difficult book to evaluate and recommend to others. It's full of incredibly useful design concepts. But the concepts are abstract and may be difficult for some to apply to software design (e.g., affordances, conceptual models, mapping). It's written by one of the world authorities in usable design, Donald Norman. However, Norman's writing style alternates between the dry description of the concepts and the more interesting real-word examples of those concepts. But, most of the the real-world concepts presented throughout the book are not software-based (e.g., telephones, doors, appliances). However, all of the concepts are incredibly important to the design of usable software. In the end, if you can make it through the book and can see the application of these proven design concepts to your software efforts, then it will have been worthwhile.

The Inmates are Running the Asylum:
Why High-Tech Products Drive Us Crazy and How to Restore the Sanity

Every once in a while you'll read a book or part of a book that completely shifts your thinking. This is one of those books. Alan Cooper (father of Visual Basic) presents for us a litany of horrific examples of interface design, and lays out the case for why spending time and money up front on usability and interaction design will produce the greatest returns of all the steps in software development. But the paradigm shift occurs in Chapters 9 and 10, "Designing for Pleasure", "Designing for Power", where Cooper hits home the power of the user-centered design process and illustrates the inherent mistakes which almost all software developers make during development. Here's a hint: if you start with requirements specifications, you're already screwed.

Web Development with JavaServer Pages
This book is subtitled, "A practical guide for designing and building dynamic web services". Yeah, right. Although the book is aimed at beginning to intermediate JSP developers, the authors fail miserably to communicate to their target audience. Basically, you'll find yourself re-reading section after section, wondering what the authors are trying to say, and why the book is so chock full of Java code listings, with only a smattering of JSP. Other books handle the learning curve of JSP much more effectively. In fact, you're better off just using any of a number of tutorials on the Internet for learning the basics and intermediary aspects of JSP. What the authors should have done is follow the lead set with PHP and MySQL Web Development. In this case, the "practical guide" was practically useless.

PHP and MySQL Web Development
This is a well-written book for learning how to build Internet applications with two of the most popular open-source web development technologies. PHP is one of the big four server-side scripting languages (along with ASP, ColdFusion, and JSP) and MySQL is one of the best high performance, scalable web-based RDBMS systems available. Together, they provide a powerful combination. The book is divided into two sections; the first half of the book gets you up to speed with both PHP and MySQL, while the second half presents some practical projects. The projects are the real jewel of the book. Not only are the projects described and constructed in a logical, component-based manner, but the selection of projects represents an excellent cross-section of common components that are built into many web sites, including: user authentication and personalization, a shopping cart, content management system, web-based email service, mailing list manager, and web forums. Because of the selection and clarity of the projects, this book makes a great general purpose reference for how to build these types of web applications, no matter which implementation language you choose.

Rapid Development: Taming Wild Software Schedules
This book should be read, re-read, memorized, and used by anyone involved in the planning, management, development, or deployment of software. It's that good. Steve McConnell presents a succinct, well organized collection of the lessons learned and best practices in software engineering over the last three decades.

Don't Make Me Think: A Common Sense Approach to Web Usability
This is the best book I have read for designing effective web page interfaces. Steve Krug systematically marches through a no-holds barred, common sense approach that will have you building more effective web sites immediately. While the book may be thin (200 pages), it's chock full of excellent, time-tested concepts on practically every page. There is a downside to the book though--after reading it, you will undoubtedly look at any interface, whether digital or structural, and ask, "Why did they design it like that? It should be like this". That's about the biggest complement you can give a book.

The Deadline: A Novel About Project Management
Deadline follows the two-year fictitious journey of IS project manager Webster Tompkins, illustrating the lessons he learns along the way. I bought this book primarily due to the great reviews it garnered on Amazon.com. After all, you can't go wrong when a book rates 4.5 out of 5 stars from over 25 readers, can you? Yep. This book was terrible, because of two very big problems: the book didn't say very much in 300+ pages and what it did say I don't agree with (it also tends to contradict much of Tom Peter's In Search of Excellence--see below). Or, to state it another way, the book points out about five very useful lessons/pieces of information, but takes forever to do so. Those lessons could have been summarized in about five pages--with compelling examples.

Philip and Alex's Guide to Web Publishing
I thought I knew a lot about building good web sites, until I started reading this book. The author, Philip Greenspun is a professor of Computer Science at MIT, runs a successful web development firm, and has built over 100 large-scale sites. The purpose of the book is twofold: to share the author's mistakes and successful strategies so that hopefully you don't have to make the same mistakes, and secondly, to emphasize how best to leverage the collaborative power of the Internet to provide services that were impossible or impractical before. Now I know how to properly engineer an RDBMS-backed site, how to build a personalization system, how to build an online community-based system (correctly), and how to build a content management system--and tie it to the personalization system. I have already incorporated many of the core concepts of the book into my own projects. This is the best web publishing book I have read to date. You can now read the entire book online.

In Search of Excellence: Lessons from America's Best Run Companies
It's amazing how many people have read this classic Peters and Waterman book. It's even more amazing then how most companies have simply ignored the lessons illustrated within, only to continue on their dismal path of mediocrity. The basic lesson to be learned is that if your company religiously follows the core tenets outlined in the book, then your company will be the leader in your industry, because you will be the only company to do so. So why is this circa 1980's book on this list? Because the principles apply just as much today, and they apply equally well to web sites. If you read this book, absorb all of the lessons, and practice them in your daily activities, then you will have learned the most important lesson in your business life. This is the most important book on the list.

Code Complete: A Practical Handbook of Software Construction
Most programmers cannot create reliable software. Most programmers do not construct computer programs correctly, regardless of methodology, language, platform, etc. For those who don't have a formal education in computer programming (e.g., Computer Science), or for those who don't want to forget the important concepts they did learn, Steve McConnell presents a classic text that drives all of these concepts home. McConnell covers everything involved in the process of constructing code, from methods of decomposition, to methods for prioritizing code comments. This book should be read by anyone who wants to improve the software they create.

After the Gold Rush: Creating a True Profession of Software Engineering
I didn't learn very much from this book--primarily because it covered so much ground that I was already familiar with, as a member of the ACM and IEEE Computer Society. Basically, After the Gold Rush is Steve McConnell's 150-page treatise on the current and proposed future state of the software engineering profession. McConnell examines, compares and contrasts software engineering with other engineering disciplines, and concludes that if we are to build more consistently reliable software systems, then we must elevate programming from a craft to a true engineering profession. The remainder of the book details how this can be accomplished. So, while I was already familiar with the difference between an education in information systems versus computer science versus software engineering, and was already familiar with the contents of the Software Engineering Body of Knowledge (SWEBOK), others may find this book very illuminating.

Software Project Survival Guide
Most of us have been involved with software projects that we would just as soon forget--or at least run away from screaming. If you want to learn how software projects should be run, or how to run one correctly yourself, then Steve McConnell presents a straightforward, common-sense approach that can be applied to all types of projects. The companion web site provides a complete collection of templates to support all aspects of managing a software project.

Secrets of Successful Web Sites: Project Management on the World Wide Web
I had high hopes for this book when I started reading it. After all, David Seigel is highly regarded around Internet circles as a web design guru. Unfortunately, Siegel's graphic design background permeates his company's project management philosophy for building web sites. Basically, he advocates managing the process of building web sites like you would manage a graphic design project. Whether you agree with this or not (personally I don't), this book only contains about one-tenth of the project management depth of McConnell's book (see above).

Information Architecture for the World Wide Web
So, you know how to create web pages, maybe even an entire web site. But do you really know how? Do you understand how to create a site that is massively scalable from a content and navigational perspective? This book will show you how. If you read any book about site design, this should be the first, the foundation. Already a classic. And under 200 pages.

Designing Web Usability: The Practice of Simplicity
This book summarizes what Jakob Nielsen has been trying to tell us for years about building usable software. Here he applies it to the web. This is probably the best book out there for learning to create web interfaces that won't send users clicking away after two seconds. My only complaint about the book is that he keeps reiterating the same core points over and over again, chapter after chapter. If it's so simple, then why am I reading 500 pages? A good book, but probably could have been condensed more efficiently.

Homepage Usability: 50 Websites Deconstructed
This is Jakob Nielsen's more pragmatic follow-up book to Designing Web Usability. The book is divided into two parts. In the first half, Nielsen presents 113 guidelines for designing home pages derived from research conducted by the Nielsen/Norman Group. The second half (and bulk of the book) consists of the practical application of these guidelines in the analysis of 50 website homepages. The 113 guidelines are excellent, summarizing a great deal of HCI research and will be beneficial to anyone designing websites. The second half starts off strong with insightful narratives as Nielsen deconstructs each homepage, clearly illustrating the guidelines. However, after reading about ten or so of the critiques, they become quite monotonous, as each homepage clearly makes the same mistakes as the prior one. If you can manage to get through the deja vu, then the 113 guidelines will surely be imprinted in your brain and on your work.

Web Pages That Suck
Now here's a book that covers a lot of the same ground as Nielsen's Designing Web Usability (see above), yet in much fewer pages and with some great humor. Unfortunately, the material does not delve as deep as Nielsen does, and some of the topics may be slightly dated, whereas Nielsen's concepts are more sustaining. Both books have great examples, so which one should you read? Probably both--read this one first, since it will go a lot faster and is more humorous, and then read Nielsen to delve into a greater understanding of the concepts.

Dynamic HTML: The Definitive Reference
I use this book as my first point of reference for all those technical details regarding HTML, Cascading Style Sheets (CSS), JavaScript, and the Document Object Model (DOM). What I really like about this reference tome (1000+ pages) is how every element, tag, attribute, etc. clearly denotes which browser/browser version supports the item. It's nice to be able to carry around a single book that can answer so many questions. Highly recommended.

Professional Active Server Pages
Most ASP developers agree that if you're going to buy just one book to learn ASP, then this is the book to get. I agree. Based on other readers recommendations, I bought this book to learn the topic, read it from cover to cover, and afterwards felt very comfortable when handling any ASP-related task. However, be prepared. This book is a slow 1000+ page read, densely packed with both information and small type.

ASP in a Nutshell
This is an excellent companion book to Professional Active Server Pages (see above). Like most O'Reilly Nutshell texts, this book is designed more as a reference aid, rather than a learning text. If you buy both the Professional ASP tome, and this reference guide, you've bought everything you need for ASP.

Instant ASP Scripts
This book was an impulse buy at a local computer show. Don't do that. After I got home and had a chance to thoroughly review the content, I discovered that--there really wasn't much content. Basically, the book is an organized collection of pre-built ASP services for automating common tasks, such as usage tracking, personalization, and various company intranet and human resources tracking tasks. While the book contains a CD with all of the ASP code ready for you to customize, it does not include corresponding Microsoft Access databases to support the code. Since most of the services described within are dependent upon an RDBMS, the author/publisher should have a least included sample databases, so that working examples could be studied. That said, I have incorporated several of the ideas (but not necessarily the code) contained within the book into my own projects. This book is probably most useful for a beginner level ASP student looking for ideas and examples related to bringing a company's intranet services up to date. All others can find ample examples on various Internet sites.

The Soul of a New Machine
A non-fiction novel about a company (Data General) building a computer in the early 1980s. How could that be entertaining? Well, it won a Pulitzer Prize, so that might pique our interest a little. Ah, now I see. It's more about the people building the computer than the computer and the computer industry. The interaction, the relationships, the stress, striving for a goal, working as a team. Tension. Failure. Then Success (or is it?). Any book that you can still vividly remember fifteen years after you read it is a great book--which is why the publisher recently reprinted it. Check it out. You'll read this book fast.

The Cuckoo's Egg: Tracking a Spy Through the Maze of Computer Espionage
This book is also a non-fiction novel, like the book above, but this time we have an unknown spy and undoubtedly, one of the most unusual "detectives" that you will ever meet. This is another book that I couldn't put down. I think you'll like it too.

The Circle of Innovation
From the first page of the book 'till the last, you'll realize that Tom Peters (In Search of Excellence) is making you think differently. Pages are printed sideways, then normally, with extremely large type, then small type. Interspersed are ideas and facts that are thought provoking and sometimes, eye-opening. That's the point. Most of the ideas are applicable to building successful web sites or web-based businesses.