Take this book and the ASP.NET AJAX Framework with two grains of salt, if you're serious about AJAX then learn JavaScript and look into the alternative AJAX Libraries like: jQuery, Scriptaculous, Dojo, Mootools, and YUI.

This book lacks objectivity and often suffers from hype. The authors came across as lacking proficient experience with the JavaScript language, or exposure to other AJAX Frameworks / Libraries, or sufficient experience using the ASP.NET AJAX Framework in real world situations.

Comments like: "we recommend that...", "because it makes no sense...", "you must understand X,Y,Z to run complex client-side code without writing a single line of JavaScript" were discouraging, and always left me hanging. Good books answer more than the "hows" - comments like "you must rely on a special..." are a cry for more research.

The book skims over the bigger picture of why the ASP.NET AJAX framework is implemented, or where its going. Instead it presented many examples of "how-to" implement the various ASP.NET AJAX constructs and patterns. It would have been nice to see some real world examples of why the ASP.NET AJAX client-side typing system is useful, or why the AJAX Framework's extended JavaScript objects are useful and how these contrast to what JavaScript already provides, or what happens behind the scenes when a class is registered through client-side code, or why the AJAX Framework prefers declarative syntax (XML) over imperative syntax, and to have some real in-depth discussions on performance implications.

In addition to these disappointments, the ASP.NET AJAX Framework itself has serious technical flaws, it's too heavy weighted (bloated) for practical use - aside from demos you won't see this framework used in the real world. It's a short lived framework, many of the other AJAX Libraries already offer superior performance and better user experience I was disappointed with the server-centric approach the ASP.NET AJAX Framework and this book take, and was disappointed to have JavaScript continually swept under the carpet as magic.

Code Complete by Steve McConnell is the convergence (the crossroads) of experience, research, and theory. This book is invaluable, the Holy Grail of programming reference books. McConnell's writing style is clear, concise, easy to understand and often humorous.

Programmers on every level (from introduction to master) will benefit from reading this book. Programmers at the introduction level may find some topics advanced, but references to additional resources are close at hand. This book covers a broad range of interconnected topics ranging from: variable names, code-tuning, personal character, managing your manager, gonzo programming and much more. The emphasis is always on successful software design techniques.

McConnell doesn't shy away from presenting hard data and details; he nails the "whys" that so many other texts avoid.

Selected quotes from Code Complete:

"People have already made all the mistakes that you're making now, and unless you're a glutton for punishment, you'll prefer reading their books and avoiding their mistakes to inventing new versions of old problems." (Chapter 35)

"Once a programmer realizes that programming principles transcend the syntax of any specific language, the doors swing open to knowledge that truly makes a difference in quality and productivity." (Preface)

"The value of hands-on experience as compared to book learning is smaller in software development than in many other fields" (Chapter 35)

It's interesting to note that Code Complete is a required read to become a practitioner (intermediate) level employee in McConnell's company (Construx).

Code Complete is often compared with The Pragmatic Programmer: From Journeyman to Master [Hunt, Andrew, and Thomas, David]; the topics covered in the Pragmatic Programmer are a small subset of Code Complete. Code Complete is consistently written at a higher level, and offers more references for continual research and professional development. But don't take my word for it; read both, the Pragmatic Programmer makes a good prerequisite to Code Complete.

Hailing this book as "The Holy Grail of programming references" may seem fanatical, but I have yet to find a book that remotely measures up to Code Complete.

Design Patterns Explained, is easy to read, informative, and like the title suggests, offers a truly new unique perspective on design patterns.

I enjoyed how the authors extend the software "construction" metaphor (software architecture, scaffolding, plugging in code, etc...) a couple steps further, drawing parallels with Christopher Alexander's (a well known architect's) essay The Nature of Order: An Essay on the Art of Building and the Nature of the Universe. In this particular essay Alexander attempts to decompose good architectural design into patterns and the authors of this book clearly take Alexander's work into the realm of design patterns.
Similarly fascinating were the parallels drawn from anthropologist Ruth Benedict's work, where the authors suggest that good design is culturally transcending.

Design Patterns Explained is a nice supplement to Design Patterns: Elements of Reusable Object-Oriented Software [Gamma, et. al.] and should be read concurrently. As other reviews have pointed out; this book does tend to be verbose in sections, it digresses at moments, and is targeted at the introductory (journeyman) level.
Regardless, it's an interesting read.

Design (Crash Course Series) [Thomas Hauffe] is a condensed history of design from the 18th through 20th century. Hauffe's writing style is interesting, informative and well thought-out. The book itself is visually stunning (a design feat in itself) with high quality images and an intuitive layout. Through the text, Hauffe explores the external influences - the developments and effects of technological advancements throughout time and the implications on design.

As a software engineer and an admirer of design / architecture, I find this small pocket book an excellent source of inspiration and an intriguing read. The factors influencing design also impact the realm of software design (a subset of design in general).
Technical, economic, aesthetic, and social developments along with political, psychological, cultural, ecological, and global influences will continue to impact software design (and all types of design). Throughout the text we can see that design is an integral part of history, and that innovation has been happening for centuries (designers have been constantly improving existing ideas). We can also observe that design is iterative (cyclic) and often occurs in patterns (similar to design patterns in the software realm).

This is an excellent book, a great source of inspiration. Many parallels can be drawn throughout this text and applied to any specific type of design.

We can learn more from history than we may think. Read!

Robert L. Glass presents a collection of facts and fallacies that are frequently forgotten, and fundamental to building software. Glass best states the purpose for writing this book; while reading the book you may find yourself thinking: "'oh, yeah, I remember that one' and then muse about why you forgot it over the years." (Introduction).

For each fact or fallacy, Glass provides a discussion, the controversies involved, and additional references. The discussions bring together Glass's extensive computing experience (50 years), his research and numerous references (from both academics and practitioners). Glass consistently emphasizes the importance and need for remaining objective.

Glass's writing style is professional, and terse, but the experience and content embodied within this text is invaluable. This is an excellent book, a stimulating read, a source of inspiration.

Selected quotes:

"Fact 16: Reuse-in-the-large (components) remains a mostly unsolved problem, even though everyone agrees it is important and desirable" (Chapter 1)

"Fallacy 3: Programming can and should be egoless." (Chapter 5)

"Fallacy 8: Given enough eyeballs, all bugs are shallow. (Linus's Law)" (Chapter 5)

This book is for ANYONE interested in building software (practitioners, managers, team leaders, students, faculty, researchers, etc...).

This book is a fantastic reference. So many technical books typically live short lives, we use them once on a single project and never touch them again, however David Flanagan's JavaScript: The Definitive Guide has clear value and longevity.

This book provides 350+ pages of reference material for the Core JavaScript Language and Client-side JavaScript (the online Mozilla Developer Center is one of the few references that comes close to this level of comprehensive reference). In addition to these 350+ pages of reference material, there are 500+ pages of dialog that linearly walk us through the JavaScript fundamentals into more complex concepts. This books huge size (900+ pages) can be daunting, and is one definite drawback. Its sweeping breadth of topics (from JavaScript language operators to using Flash with JavaScript) can be both informative or confusing - reading JavaScript: The Good Parts (140+ pages) concurrently will certainly complement your understanding of JavaScript.

In short this book is the most complete references for JavaScript as we've come to know it, it covers JavaScript from A-Z, it's permeated with good advice - and for good reasons too, this is its 5th Edition, it has been recognized as one of the best books in JavaScript, and has been reviewed or edited by some of the JavaScript greats: Peter-Paul Koch (ppk on JavaScript), and Douglas Crockford (JavaScript: The Good Parts) to name a few.

I highly recommend this book, and am looking forward to Flanagan's newest book The Ruby Programming Language.

Weighing in at 140+ pages of content, this book cuts through the obscurities, pleasantries, and filler found in most technical books. Instead, this book dives straight into the heart of the JavaScript language. It presents the clearest comprehensive explanation of what makes JavaScript a great programming language that I've encountered to date. It nails the important concepts, like JavaScript's: object oriented nature, its classless (pseudoclassical) nature, and functional nature. While covering the fundamentals like JavaScript's: functions, lexical scoping, lambdas, prototypal inheritance, and functional inheritance.

This book's size makes it approachable for all audiences, its style is terse and concise. This book has the potential to do for JavaScript, what Richie's inspirational classic the C Programming Language did for the C language.

JavaScript is the programming language of the web (AJAX), and this book will guide you through the good parts of this often misunderstood language - while this book is an excellent reference, it is not intended to replace JavaScript: The Definitive Guide, you'll do best to have both these books on hand.

If you enjoyed (or are considering) this book then you may want to hear more of what Douglas Crockford has to say, check out his great JavaScript video series on the YUI Theater.

Peopleware: Productivity Projects and Teams [Tom DeMarco, Timothy Lister] was first published in 1987 - three decades later it is a revered classic. DeMarco and Lister focus on the human factor of software development (managing people). Through their 30 years of project management experience and consulting they share what went right, and more importantly, what went wrong - so we can learn from their mistakes.

This series of essays cover a wide variety of topics ranging from: office environments that encourage work, the importance of the closed door (read: "cubicles are BAD"), the significance of "flow" and creativity, the dangers and hidden cost of turnover, the importance of hiring and keeping the right people, how to retain employees, how to encourage productivity, the importance of a "jelled team", the dangers of teamicide, how not to manage people, and many other equally interesting topics.

Some quotes I found interesting:

"No one can really work much more than forty hours, at least not continually and with the level of intensity required for creative work." (Chapter 3)

"the process of improving productivity risks worsening turnover" (Chapter 3)

"People under time pressure don't work better; they just work faster." (Chapter 3)

"People who had ten years of experience did not outperform those with two years of experience." (Chapter 3)

"people who perform better tend to gravitate towards organizations that provide a better workplace." (Chapter 8)

"the total cost of replacing each person is the equivalent of four-and-a-half to five months of employee cost or about twenty percent of the cost of keeping that employee for two years on the job." (Chapter 16)

This book continues to change the way I view my job, organization, and career. Practitioners and authors like: Steve McConnell, Robert L. Glass, and Joel Spolsky heavily cite the industry-shattering truths originally exposed by Marco and Lister. This book should be on every professional's shelf along side other classics like: The Mythical Man-Month, and Code Complete.

The Software Project Survival Guide by Steve McConnell remains applicable today as when first published in 1995. McConnell has a clear knack for combining research, experience, and theory. His writing style is clear, concise, and easy to understand.

McConnell approaches the topic of project management (design through to delivery) from a high abstract level; he outlines the best practices, provides comprehensive checklists, but leaves the fine details to other authors. McConnell States, "Whereas this book provides a big picture technical framework for a project, [Fergus] O'Connell's book focuses on the many specific activities a project manager must perform." (Part IV)

McConnell's writing style maintains a high sense of integrity and he always encourages personal research and development through his extensive use of external references.

Selected quotes:
"Software development is inherently an exercise in climbing steep learning curves - an exercise in problem solving - and the learning curves don't disappear" (Chapter 17)

"No individual is a success who hurts the team, and no individual is a failure who helps it." (Chapter 18)

This is an excellent book, a great reference; although a little too heavy to be comparable to the "first aid kit you carry in your backpack" (Chapter 20).

The "Cone of Uncertainty" (chapter 3) and the "Survival Needs" section (chapter 1) were quite interesting. In the "Survival Needs" section McConnell draws many parallels with the basic human needs and the basic needs for a successful project. Similarly intriguing is his Project Team's Bill of Rights (chapter 1).

Be sure to visit the book's website it provides the chapter checklists in digital form and many other useful resources.

There is no one-size-fits-all or simple solution - this book is not an exception. Continue reading other project management books and some of McConnell's more recent texts like Software Estimation Demystifying the Black Art.

The Art of Looking Sideways [Alan Fletcher] is inspirational, intelligent, invigorating, and stimulating. This book is a collage of witty text, images, metaphors, idioms, paradoxes, and humor.

I believe W. Todd Dominey (a preceding reviewer) said it best:
"The Art of Looking Sideways is an instruction manual of sorts for adults to deconstruct their preconceived belief systems of reality. Readers are encouraged to look, see, explore, turn upside down, rip apart, and to ultimately rebuild that which everyday people believe to be true through a series of word plays, found quotations, paradoxes, and unusual truths. There are no answers. Just questions, and differences of perception."

I use this book as a source of inspiration to regain mental clarity, a right hemisphere brain stimulant if you will.
Five minutes of looking sideways is often the remedy for my worst mind block, leaving me reinvigorated with a fresh perspective. :)

A philosophic question to ponder as you flip through this book: "Which way is up?"

This is an excellent book.

The Best Software Writing I [Joel Spolsky], is a nicely rounded selection of essays, blog posts, and other intriguing software related tidbits weaved together by Joel Spolsky's witty dialog. This book is easy to read, light, humorous, and thought provoking. In an every changing software industry, books like this give us a broader picture of what's happening in the industry. It's a great book to read during your daily commute, pass around the office, leave in the bathroom, or give to a friend when your finished.

I highly recommend this and other books by Spolsky, check out his blog too.

The Mythical Man-Month (M M-M) [Frederick P. Brooks] is often referred to as the most influential Software Engineering books ever. Despite being originally published in 1975 the content remains timeless, equally valuable today.

The central theses of these essays revolve around conceptual integrity - maintaining the product focus in large systems (IBM's OS/360). Brooks touches on many other topics such as the need for a software process, how to manage a team, and the importance of distinguishing between the architecture, design, and development processes. Brooks approaches most subjects from an abstract (managerial) perspective requiring personal interpretation (reading between the lines).

"If a system is to have conceptual integrity, someone must control the concepts." (Chapter 4)

Throughout the book Brooks continually emphasizes the need for remaining analytical (objective), and his famed "No Silver Bullet" essay can be found in Chapter 16.

"Not only are there no silver bullets now in view, the very nature of software makes it unlikely that there will be any-no inventions that will do for software productivity, reliability, and simplicity what electronics, transistors, and large-scale integration did for computer hardware." (Chapter 16)

The Mythical Man-Month is enjoyable, a wealth of information, and easy to read. Some readers may be discouraged, as this book requires personal interpretation, but in doing so the M M-M facilitates inspiration, introspection and debate. Anyone associated with the software industry (introduction level programmer through to management) can appreciate what Brooks has to say.

If you're looking for a comprehensive checklist or an immediately implemental solution then read what other authors like Steve McConnell (Code Complete: A Practical Handbook of Software Construction) and Robert L. Glass (Facts and Fallacies of Software Engineering) have to say.

"The tar pit of software engineering will continue to be sticky for a long time to come." (Chapter 18)

The Pragmatic Programmer: From Journeyman to Master, should be read by anyone involved with the software industry. The tone of this book is casual and often humorous making it fun, enjoyable and easy to read.

As the title implies, this book is targeted towards the programmer or developer (the construction phase of software engineering). The text outlines principals and practices that are common sense, but that every practitioner SHOULD be aware of. However, in reality most of these principals and practices are overlooked. The book borders on the obvious, but keep in mind that "the obvious ... is never seen until someone expresses it simply." (Kahlil Gibran) The authors express good programming principals, outline the collection of tools every practitioner should have, and offer priceless advice in a simple manner.

I found the authors offering a lot of "Hows" and "Whats" with out answering the "Whys". Code Complete [Steve McConnell] answers most (if not all) of these questions and in doing so, is three times the size. The Pragmatic Programmer is also somewhat short-lived - a new edition should be in the making. For example the collection of tools described within the text is changing (Subversion seems to be replacing CVS, etc...).

It's interesting to note that both authors (Andrew Hunt, David Thomas) are authors of the Agile Manifesto, and have a series of Pragmatic Programming books (Pragmatic AJAX, Agile Web Development with Rails, Programming Ruby, etc...).
Their other texts are equally humorous and easy to read.

The Pragmatic Programmer makes an excellent prerequisite to Code Complete. I can attest the "[Pragmatic Programmer] will help you become a better programmer" (Preface), but reading additional software engineering resources will make you an even better programmer.