Recommended books about design pattern

You're not alone.

At any given moment, somewhere in the world someone struggles with the same software design problems you have. You know you don't want to reinvent the wheel (or worse, a flat tire), so you look to Design Patterns--the lessons learned by those who've faced the same problems. With Design Patterns, you get to take advantage of the best practices and experience of others, so that you can spend your time on...something else. Something more challenging. Something more complex. Something more fun.

You want to learn about the patterns that matter--why to use them, when to use them, how to use them (and when NOT to use them). But you don't just want to see how patterns look in a book, you want to know how they look "in the wild". In their native environment. In other words, in real world applications. You also want to learn how patterns are used in the Java API, and how to exploit Java's built-in pattern support in your own code.

You want to learn the real OO design principles and why everything your boss told you about inheritance might be wrong (and what to do instead). You want to learn how those principles will help the next time you're up a creek without a design pattern.

Most importantly, you want to learn the "secret language" of Design Patterns so that you can hold your own with your co-worker (and impress cocktail party guests) when he casually mentions his stunningly clever use of Command, Facade, Proxy, and Factory in between sips of a martini. You'll easily counter with your deep understanding of why Singleton isn't as simple as it sounds, how the Factory is so often misunderstood, or on the real relationship between Decorator, Facade and Adapter.

With Head First Design Patterns, you'll avoid the embarrassment of thinking Decorator is something from the "Trading Spaces" show. Best of all, in a way that won't put you to sleep! We think your time is too important (and too short) to spend it struggling with academic texts.

If you've read a Head First book, you know what to expect--a visually rich format designed for the way your brain works. Using the latest research in neurobiology, cognitive science, and learning theory, Head First Design Patterns will load patterns into your brain in a way that sticks. In a way that lets you put them to work immediately. In a way that makes you better at solving software design problems, and better at speaking the language of patterns with others on your team.

Very good book with a very good concept. It takes your hand and follow you in understanding some important programming patterns which will make your life easier.

This was my first book from Head First, and i love it! The book uses an easy approach (besides the schema in each chapter) to make you understand the different patterns. I think the book is good for junior and mid senior people.

This book is like eating icecream. You expend Zero effort in learning valuable information about design patterns for oo development.

First, a little background: I have been programming since 1998 and my primary programming language is C#. My main area of development is ASP.NET websites.

For years I have been trying to get my head around software design patterns, but I kept running into road blocks. I tried learning about them from a combination of websites and books, but none of them seemed to communicate the practical reasons for learning design patterns. I decided to give up on learning them.

Several years went by and the gnawing question about the usefulness of software design patterns resurfaced in my head. I came across Head First Design Patterns, saw the great reviews and decided to take a chance. I am sure glad I did.

Not only is this easily the best design patterns book I have read, this may be one of the best books, teaching a complicated technology topic, I have ever read. This book was created with me in mind. The book is educational, entertaining, and does a good job of showing the practical side of the topic. The examples are all in Java, but I was able to easily translate them into C#.

If you want to learn object oriented design patterns, buy this book. I will definitely be checking out other Head First titles.

This is a book that I recommend to all of the software developers I work with, it is so much more than the gang of 4, it is actually readable. The unique format used to address the topics helps with retention and understandability. The only complaint that I would have about the book, and the reason I gave it 4 stars, is that the examples used are impractical and sometimes silly. The authors also could have alluded more to the usages of algorithms and efficiency of code.

�g Framework Design Guidelines is one of those rare books that can be read at different reading levels and can be useful to different kinds of developers. Regardless of whether you want to design an effective object model, improve your understanding of the .NET Framework, borrow from the experience of software gurus, stay clear of the most common programming mistakes, or just get an idea of the huge effort that led to the .NET initiative, this book is a must-read.�h

�|Francesco Balena, The VB Migration Partner Team (www.vbmigration.com), Code Architect, Author, and Microsoft Regional Director, Italy

�|

�g Frameworks are valuable but notoriously difficult to construct: your every decision must be geared toward making them easy to be used correctly and difficult to be used incorrectly. This book takes you through a progression of recommendations that will eliminate many of those downstream �eI wish I�fd known that earlier�f moments. I wish I�fd read it earlier.�h

�|Paul Besly, Principal Technologist, QA

�|

�g Not since Brooks�f The Mythical Man Month has the major software maker of its time produced a book so full of relevant advice for the modern software developer. This book has a permanent place on my bookshelf and I consult it frequently.�h

�|George Byrkit, Senior Software Engineer, Genomic Solutions

�|

�g Updated for the new language features of the .NET Framework 3.0 and 3.5, this book continues to be the definitive resource for .NET developers and architects who are designing class library frameworks. Some of the existing guidelines have been expanded with new annotations and more detail, and new guidance covering such features as extension methods and nullable types has also been included. The guidance will help any developer write clearer and more understandable code, while the annotations provide invaluable insight into some of the design decisions that made the .NET Framework what it is today.�h

�|Scott Dorman, Microsoft MVP and President, Tampa Bay International Association of Software Architects

�|

�g Filled with information useful to developers and architects of all levels, this book provides practical guidelines and expert background information to get behind the rules. Framework Design Guidelines takes the already published guidelines to a higher level, and it is needed to write applications that integrate well in the .NET area.�h

�|Cristof Falk, Software Engineer

�|

�g This book is an absolute must read for all .NET developers. It gives clear �edo�f and �edon�ft�f guidance on how to design class libraries for .NET. It also offers insight into the design and creation of .NET that really helps developers understand the reasons why things are the way they are. This information will aid developers designing their own class libraries and will also allow them to take advantage of the .NET class library more effectively.�h

�|Jeffrey Richter, Author/Trainer/Consultant, Wintellect

�|

�g The second edition of Framework Design Guidelines gives you new, important insight into designing your own class libraries: Abrams and Cwalina frankly discuss the challenges of adding new features to shipping versions of their products with minimal impact on existing code. You�fll find great examples of how to create version N+1 of your software by learning how the .NET class library team

created versions 2.0, 3.0, and 3.5 of the .NET library. They were able to add generics, WCF, WPF, WF, and LINQ with minimal impact on the existing APIs, even providing capabilities for customers wanting to use only some of the new features, while still maintaining compatibility with the original library.�h

�|Bill Wagner, Founder and Consultant, SRT Solutions, author of Effective C# and More Effective C#

�|

�g This book is a must read for all architects and software developers thinking about frameworks. The book offers insight into some driving factors behind the design of the .NET Framework. It should be considered mandatory reading for anybody tasked with creating application frameworks.�h

�|Peter Winkler, Sr. Software Engineer, Balance Technology Inc.

�|

�gAn instant classic.�h

�|From the Foreword by Miguel de Icaza

�|

Framework Design Guidelines, Second Edition, teaches developers the best practices for designing reusable libraries for the Microsoft .NET Framework. Expanded and updated for .NET 3.5, this new edition focuses on the design issues that directly affect the programmability of a class library, specifically its publicly accessible APIs.

�|

This book can improve the work of any .NET developer producing code that other developers will use. It includes copious annotations to the guidelines by thirty-five prominent architects and practitioners of the .NET Framework, providing a lively discussion of the reasons for the guidelines as well as examples of when to break those guidelines.

�|

Microsoft architects Krzysztof Cwalina and Brad Abrams teach framework design from the top down. From their significant combined experience and deep insight, you will learn

• The general philosophy and fundamental principles of framework design
• Naming guidelines for the various parts of a framework
• Guidelines for the design and extending of types and members of types
• Issues affecting�|and guidelines for ensuring�|extensibility
• How (and how not) to design exceptions
• Guidelines for�|and examples of�|common framework design patterns

Guidelines in this book are presented in four major forms: Do, Consider, Avoid, and Do not. These directives help focus attention on practices that should always be used, those that should generally be used, those that should rarely be used, and those that should never be used. Every guideline includes a discussion of its applicability, and most include a code example to help illuminate the dialogue.

�|

Framework Design Guidelines, Second Edition, is the only definitive source of best practices for managed code API development, direct from the architects themselves.

�|

A companion DVD includes the Designing .NET Class Libraries video series, instructional presentations by the authors on design guidelines for developing classes and components that extend the .NET Framework. A sample API specification and other useful resources and tools are also included.

*Capturing a wealth of experience about the design of object-oriented software, four top-notch designers present a catalog of simple and succinct solutions to commonly occurring design problems. Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves. *The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently.

Design Patterns is a modern classic in the literature of object-oriented development, offering timeless and elegant solutions to common problems in software design. It describes patterns for managing object creation, composing objects into larger structures, and coordinating control flow between objects. The book provides numerous examples where using composition rather than inheritance can improve the reusability and flexibility of code. Note, though, that it's not a tutorial but a catalog that you can use to find an object-oriented design pattern that's appropriate for the needs of your particular application--a selection for virtuoso programmers who appreciate (or require) consistent, well-engineered object-oriented designs.

I thinks this is a great book for anyone wanting to learn or have a reference on design patterns. It does expect the user to know OO C++. It is definetly a book for software engineers to have on their collection.

The concept of design patterns transcends programming languages. If you wish to think "outside the box" yet be effective and efficient, either this book will provide the answer or help you think in ways that you can develop our own design. A must read.

I would say this book was a bit old school in it's approach and content, but was exactly what i needed to get a good starting point in understanding how to use design patterns in my software designs. The case studies it presented were simple problems but contained practical elements I could apply to my next big project.

This is the most recommended book on object oriented design. I can see now.what all the hype is about. I have been a developer for almost six years now. I have been using object oriented languages for some time. Despite the experience with the technologies, I didn't have a good working knowlege of how to effectively implement the technology and methodology in my own code. That is, until I read "Design Patterns". It has opened my eyes and I understand the concepts of polymorphism and code reuse much more clearly now.

"Design Patterns" is easy to read, easy to understand and has great code examples that facilitate understanding. It is my opinion that if you haven't read this book and you develop with OOP, you are probably working harder and not smarter. So do yourself a favor and pick up a copy.

I give this book a 3 because it was great when it was written. But now, it is not a very good book to read. Most people who read it acknowledge they can't understand it. There are two excellent books on the market that should be read if you want to learn design patterns.

Head First Design Patterns (Head First) - is the best book to read on what patterns are as solutions to a problem in a context. Fun to read, useful, really wonderful *****.

However, if you want to learn what patterns really are - the thought process behind them, read Design Patterns Explained: A New Perspective on Object-Oriented Design (2nd Edition) (Software Patterns Series) *****

A related book that would also be a good read is Scott Bain's Emergent Design: The Evolutionary Nature of Professional Software Development (Net Objectives Product Development Series) *****

Let's give tribute to the acknowledged #1 classic in the modern software industry. But it is not the book to read to learn patterns anymore.

What exactly is a slope? What's the difference between a tile and a plate? Why is it bad to simply stack bricks in columns to make a wall? The Unofficial LEGO Builder's Guide is here to answer your questions.

Focusing on building actual models with real bricks, The Unofficial LEGO Builder's Guide comes with complete instructions to build several cool models but also encourages you to use your imagination to create your own fantastic creations.

Inside, you'll learn:

• The best ways to connect bricks and creative uses for those patterns
• Tricks for calculating and using scale (it's not as hard as you think)
• The step-by-step plans to create a train station on the scale of LEGO people (a.k.a. "minifigs")
• How to build spheres, jumbo-sized LEGO bricks, micro-scaled models, and a mini space shuttle
• Tips for sorting and storing all of your LEGO pieces

The Unofficial LEGO Builder's Guide also includes the Brickopedia, a visual guide to nearly 300 of the most useful and reusable elements of the LEGO system, with historical notes, common uses, part numbers, and the year each piece first appeared in a LEGO set.

The firm foundation for your LEGO hobby starts here!

My doughter say "Just few picture, only black and white inside, so I don't like this book"
This book may fit for middle or high school students.

A true labor of love, this is the most comprehensive guide around! A must-have for LEGO devotees.

THE UNOFFICIAL LEGO BUILDER'S GUIDE is the best "Overview" of the LEGO building system available hands down. The book has been written for beginners as well as more advanced builders. It's a great reference guide with tips, techniques and definitions for users of all ages. Anyone can buy and build a LEGO "set", but this book will give you the tools needed to build your own creations. Once those "sets" are in a hundred pieces and you want to try your hand at your own creation, this is the guide you will reach for to help you do it right.

The chapters are written is a simple easy to understand way and the flow of the material is easy to follow. There seems to be just enough information on each page that the reader does not feel like he/she is always getting lost when following the examples or descriptions. The illustrations are in black and white and are very clear and easy to see. Some might complain that the illustrations are not in color but I personally prefer the black and white. When building your own creation the lack of color is actually less of a distraction than it would be if you were building something blue and white and the illustration was red and yellow.

One of the best features of the book is the Bricktopia, a categorized list of the most commonly used LEGO pieces. It includes an illustration of the piece, a description, size and part number. I personally find it helpful to browse thru this area to get "ideas" for building projects. I have noticed pieces I forgot about that has triggered a "thats the one I could use" thought to help with a project I am working on or have been thinking of building.

I recommend this book to anyone interested in learning the foundations needed to build projects from simple to the more elaborate. LEGO builders of all ages will benefit from buying this book. Buy this book and leave it out on a coffee table and see how long it takes someone to pick it it up!

Bedford's book offers everything and anything that one could consider useful to know about building with LEGO. I love the way he describes how to design things using grids and how to organize large collections of LEGO bricks. He's even designed a game in LEGO that others can play! I highly recommend this book to all ages of LEGO builders.

An Ok book, but I was hoping that the author would go into greater details.

Designing a good interface isn't easy. Users demand software that is well-behaved, good-looking, and easy to use. Your clients or managers demand originality and a short time to market. Your UI technology -- web applications, desktop software, even mobile devices -- may give you the tools you need, but little guidance on how to use them well.

UI designers over the years have refined the art of interface design, evolving many best practices and reusable ideas. If you learn these, and understand why the best user interfaces work so well, you too can design engaging and usable interfaces with less guesswork and more confidence.

"Designing Interfaces" captures those best practices as design patterns -- solutions to common design problems, tailored to the situation at hand. Each pattern contains practical advice that you can put to use immediately, plus a variety of examples illustrated in full color. You'll get recommendations, design alternatives, and warnings on when not to use them.

Each chapter's introduction describes key design concepts that are often misunderstood, such as affordances, visual hierarchy, navigational distance, and the use of color. These give you a deeper understanding of why the patterns work, and how to apply them with more insight.

A book can't design an interface for you -- no foolproof design process is given here -- but "Designing Interfaces" does give you concrete ideas that you can mix and recombine as you see fit. Experienced designers can use it as a sourcebook of ideas. Novice designers will find a roadmap to the world of interface and interaction design, with enough guidance to start using these patterns immediately.

This book is by far the best book that does for the User Interface world of computing what Edward R. Tufte's series of books does for the writer's of technical reports and their needs to present and represent many varied types of data and data interaction. Need to show the effects of miles marched, time required to cover terrain, and temperature on Napoleon's armies march on Moscow and show the number of troops he has left alive at every point along the journey? Tufte shows how the French engineer Charles Minard did so. "Designing Interfaces" does exactly the same thing by showing how various UI pioneers have done the same for the Man-Machine interface. Want to see which issues are getting the most reporting in Google News and how fast or slow those issues are fading from the landscape? Check out the marumishi "Treemap" described on page 205 of Designing Interfaces. Highly recommended.

Nutshell review - If you design interfaces for any software project you should read this book. It covers all the bases, is extensive, comprehensive, well written and easy to use as a resource or refresher in interface design techniques.

Designing Interfaces catalogs UI design patterns in use and provides guidance in using them, with plenty of examples. It takes a consistent approach to describing each pattern: What it is, when to use it, why to use it and how to use it. The book is both a good overview and a reference. If UI design is an area of interest to you, then read through this book and then keep it available as a reference.

For many years now, I have been coding web sites and applications. Through all that time, nothing has ever been as tough for me as coming up with a design that I am truly happy with. Attempting to create an optimized and stable algorithm or coming up with the answer to a problem that requires non-conventional coding practices; these are always challenges, but ones that are most often eventually solved. Creating that mythical eye catching never-been-done-before layout is something that I have attempted and, sadly to say, usually fell short on. I suppose you'd consider this a case of a programmer wanting an application to not look like a programmer designed it. This was my reason for picking up the Designing Interfaces book.

The first chapter talks about how users think. However, as I finished the chapter introduction, I realized that the author and I are definitely coming from two very different places. In my experience, I get very little hands-on with the user base, or the client that the application is being built for. Even if I do talk to the client directly, instead of going through the levels of proper channels, they usually have a set design in mind, limiting my choices. That's not to say, however, that a good designer couldn't be creative given these design constraints. On the other hand, the author mentions that building a user profile is something that eats up a lot of time though it is always worth it, and while I agree whole-heartedly, sometimes a deadline approaches too quickly or it's just not in the budget to give this the time it truly needs. Past this quibble and reading on, the patterns of human behavior in the first chapter give an almost checklist of things to keep in mind when designing, and even though you read and probably think, "common sense", it is very helpful to have in one place.

As the chapters passed one by one, I found the same patterns in my reading emerge. Read the introduction to the chapters the first time you pick up the book to get an idea behind why that particular chapter is important, or, at the very least, for posterity. After that, just skip to the section in each chapter marked as "Patterns" when you need them. These patterns are where the book really shines. Each of these patterns are laid out in a similar way letting you quickly see what it is, when you would use it, why it is used (as in why it is beneficial to your user), how you create the pattern, and then some examples of its use. Considering that there are nine chapters, each with about ten different patterns, this book contains a wealth of information.

I was originally hoping for more of a design lesson; color theory, placement with a hint of golden ratios, maybe a small college art class packed into 331 pages. Though I did not get much of that, at least until the last chapter or two, I definitely found an excellent reference to keep by my side. For example, if I'm building a layout, I'll open the book right up to chapter 4 to see what the common options are; for showing hierarchical data, I'm opening up to chapter 6 to see when and for what reason I might want to go with a tree map over a normal tree. I couldn't recommend it more to someone wanting a helpful component pocket guide of sorts for interfaces, but if you are looking for theory, I'd go with something more geared in that direction.

While I don't own a physical copy of this book, I had used an electronic form of it in the course of my studies.

I will first forewarn those who are interested in Human-Computer Interaction (HCI) that this text does not heavily focus on the science of Psychological principles such as Gestalt Perception, nor does it concern itself with techniques/methodologies such as Threading and Model-View-Controller (MVC) to improve the performance of programs. The focus of this text falls strictly on the layout and/or graphical design in regards to interfaces and web pages.

As well, each principle has certain uses depending on the medium used, which the text does a good job of elaborating (for example, cell phone programs would not be designed the same as a full Windows Application).

A word to the wise though: Requirements must come before Design. There are certain design principles outlined in this text that cannot be realized if the very requirements of the program do not allow for it - For example, Microsoft Office 2007 has in many ways disregarded the principle of habituation/familiarity (as it looks much different from typical Windows Applications in general). One will still need the skill of compromise in order to apply the information presented here effectively in the real world.

"Head First Object Oriented Analysis and Design is a refreshing look at subject of OOAD. What sets this book apart is its focus on learning. The authors have made the content of OOAD accessible, usable for the practitioner."

Ivar Jacobson, Ivar Jacobson Consulting

"I just finished reading HF OOA&D and I loved it! The thing I liked most about this book was its focus on why we do OOA&D-to write great software!"

Kyle Brown, Distinguished Engineer, IBM

"Hidden behind the funny pictures and crazy fonts is a serious, intelligent, extremely well-crafted presentation of OO Analysis and Design. As I read the book, I felt like I was looking over the shoulder of an expert designer who was explaining to me what issues were important at each step, and why."

Edward Sciore, Associate Professor, Computer Science Department, Boston College

Tired of reading Object Oriented Analysis and Design books that only makes sense after you're an expert? You've heard OOA&D can help you write great software every time-software that makes your boss happy, your customers satisfied and gives you more time to do what makes you happy.

But how?

Head First Object-Oriented Analysis & Design shows you how to analyze, design, and write serious object-oriented software: software that's easy to reuse, maintain, and extend; software that doesn't hurt your head; software that lets you add new features without breaking the old ones. Inside you will learn how to:

• Use OO principles like encapsulation and delegation to build applications that are flexible
• Apply the Open-Closed Principle (OCP) and the Single Responsibility Principle (SRP) to promote reuse of your code
• Leverage the power of design patterns to solve your problems more efficiently
• Use UML, use cases, and diagrams to ensure that all stakeholders are communicating clearly to help you deliver the right software that meets everyone's needs.

By exploiting how your brain works, Head First Object-Oriented Analysis & Design compresses the time it takes to learn and retain complex information. Expect to have fun, expect to learn, expect to be writing great software consistently by the time you're finished reading this!

Well i haven't actually looked at this book, but I own the first edition too. My teacher marked this as required so I bought it. The first version is not only how I learned O.O.P. but also how I learned java. It is a great starter book to get the idea of objects and inheritance/polymorphism. I flipped through a few pages and it looks very similar to the first version, so I'm sure whichever you get, they will be a great asset in your learning of java and object oriented programming in java.

How I wish I'd had this book earlier in my programming career!

The Head First series use a novel teaching style that is designed to be engaging and informative and to work for a wide range of people. We all learn in different ways so this book uses them all to make sure you get the point.

The examples are clear and the concepts presented in a way that I was able to understand them and immediately began to see ways to effectively use them in my daily design, coding and testing tasks.

Even if you have been doing object oriented programming for a while you will still get a lot out of this book.

I can't recommend this book too highly.

Ray

I'm a supporter of the Head First approach to learning, but this one has failed to hit the mark. I can live with a fair number of typos (which this book certainly has), however bad or broken code in just too many places is not so easily forgiveable. The authors hammer on principles of good OO design, but clearly did not test-drive the code that is supposed to show-case those design principles. To mention a few: missing return statement (p6), ClassCastException (p212), NullPointerException (p254), an Inventory search method that will fail to find anything if an instance of type InstrumentSpec (as opposed to a derived type) is passed to it (p211,212,238) (while authors suggested on the previous page to re-design InstrumentSpec to be non-abstract for this reason), non-standard UML for implementing an interface (p224). I could probably go on, but stopped reading (maybe I'll pick up later).
Another thing I find is that there is too much fluff and repetitiveness. Some may argue this is a trademark of the Head First series, and that it helps you conquer the learning curve. I will agree on the Head First classics (you know 'm), but here it starts to get boring quickly, and you find yourself flipping instead of reading after a while...
To conclude, you'll learn a thing or two if you're relatively new to OOA&D. And although the book definitely has some good points, like the explanations of object-oriented design principles (the foundations of patterns), there are better (spell-checked and peer edited) and denser books out there.

This book is very good. Like many other Head First books, it presents material in a very fresh way that is easy to understand. If you are new to Object-Oriented programming, this book is great. If you are very well versed in Object-Oriented programming, you may find yourself a little more bored with this book. Still, it is worthwhile for all people interested.

Unless you are a very experienced object-oriented developer/architect, this is a great book.
The methodology is very intuitive and it is not a dense heavy book to read. It's actually very fun.
Be careful not to read it too casually though, as it has a lot of contents.
I like the fact that it repeats itself after every important concept, so you are less likely to skip it.
My recommendation is to do every exercise and try to think careful about the solutions the authors go through.
This is a must-have for every developer, in my opinion.

Developers of enterprise applications (e.g reservation systems, supply chain programs, financial systems, etc.) face a unique set of challenges, different than those faced by their desktop system and embedded system peers. For this reason, enterprise developers must uncover their own solutions. In this new book, noted software engineering expert Martin Fowler turns his attention to enterprise application development. He helps professionals understand the complex -- yet critical -- aspects of architecture. While architecture is important to all application development, it is particularly critical to the success of an enterprise project, where issues such as performance and concurrent multi-user access are paramount. The book presents patterns (proven solutions to recurring problems) in enterprise architecture, and the context provided by the author enables the reader to make the proper choices when faced with a difficult design decision.

This book is not for beginners. The patterns match many constructs I've built over the years. It is pretty comprehensive and a foundation for the newer patterns of SOA and WOA. A good addition to any architect's library.

Motivation

I didn't look at this book for a long time simply because of the word "enterprise." I felt the word was too overloaded to be useful. I've heard too many managers, recruiters, and other programmers use this word to mean too many different things. Fowler defines enterprise application as "the display, manipulation, and storage of large amounts of often complex data and the support or automation of business process with that data." By that definition every system I've ever worked on has been an enterprise application.

Cons

A dense, tough read. I almost wish I was at a whiteboard or kept a notepad while reading.

Pros

Fowler gives a fantastic presentation of how to design software using databases, distributed components, etc. This is given through good narratives and anecdotes of Fowler's own experiences, and also through the patterns distilled from these.

The best thing I can say about this book is I would put it fourth in the list of books-I'd-like-anybody-I'm-working-with-to-have-read, right after to Design Patterns, Refactoring, and Extreme Programming Explained.

Summary

As with most patterns books, not everything in here is an amazing revelation, but the common approach, terminology, and ways of categorizing problems and solutions make it very valuable.

Programmers who utilize design patterns and refactoring, and who work on software systems involving distributed components and/or databases should take a look at this book.

This book is a complete beginner's handbook for enterprise patterns.

1) The "Mapping to Relational Database Patterns" section discusses patterns that are completely intuitive. I recall logically coming to this conclusions when I started programming in Visual Basic in 99. Nothing new in this section.

2) The "Concurrency" section is criminal in nature and assumes that the application runs on high-cost server. Process-per-session? Thread-per-request? Come on!! Has the author missed out on the Reactor, Proactor and Active Object patterns (he does reference ACE but only as a reference). These patterns have been recognized as not scalable in the late 90s.

3)The distribution patterns are clearly incomplete and desire a lot of details.

If you're just starting out,as a System Architect :-), you'll find this useful. Otherwise, use MSDN or ACE for enterprise patterns.

Even if you don't do "Enterprise Application" development, this book is a must have in your library. If you have been developing for more than a couple of years and you haven't seen 1/2 of the patterns in this book, then you are probably doing something wrong and this book could greatly help you.

Even if you do know 1/2 or more of the patterns in this book it is a great reference to the details of these patterns. Unless you are a Sophomore Software Engineering Student I'd recommend this book over the GoF book. Gof is a must have too, but if you can only have one. Get this one!

This is a must read book if you are a developer, architect or in anyway related to technology.

<>Praise for the second edition of The Design of Sites

�|

"In my worldwide IBM marketing role, I have the benefit of working with some of the finest international interactive agencies and internal Web teams. As I read The Design of Sites, [I see] the insight from years of professional advice has been put to paper. Nowhere have I seen such a practical, effective, and easy-to-use book to solve and avoid Internet design issues. I keep a copy of the book handy to remind me of the things I forgot and to gain fresh perspectives. It never fails to deliver."
-John Cilio, marketing manager, IBM System x & z Storage Synergy

"The Design of Sites artfully brings forward the original intent of Christopher Alexander�fs pattern language into the user experience design arena. It is a valuable and comprehensive reference."

-George Hackman, Jr., senior director of User Experience for User Interface Guidelines, Patterns and Standards, Oracle Corporation

"The Design of Sites is one of the best tools I have in my usability toolbox. [These] Web UI design patterns make it easy for me to show my clients how to get the most usability bang for their buck."

-Claudia Alden Case, usability consultant and interaction designer, Alden Case Enterprises, Inc.

"If only biology class had been like this. Lucid text, bulletproof content, and a comprehensive taxonomy that�fs just as much a source of inspiration as it is a production tool. This is a really, really good book. If you build Web sites, read it."

-Marc Campbell, author of Web Design Garage

Praise for the first edition of The Design of Sites

"Stop reinventing the wheel every time you design a Web site! The Design of Sites helps you rethink your Web sites in terms of genres and patterns. Once you have identified the patterns and applied the best practices for those patterns as outlined in this book, you will reduce your design effort by 50 percent . . . at least!"

-Pawan R. Vora, vice president, Information Architecture, Seurat Company

"The content [in The Design of Sites] could make a novice into a seasoned professional over a weekend. Many companies pay a fortune for the information contained in the book�fs primary chapters."

-John Cilio, marketing manager, IBM System x & z Storage Synergy

"This book has many handy checklists for what you should and should not do in creating a conventional Web site. Just following the authors�f suggestions would put your site in the top few percent for readability and usability."

-Jef Raskin, creator of the Macintosh computer and author of The Humane Interface

"Now that The Design of Sites has made its appearance, we won't have to put up with those poorly designed Web pages. These authors have captured patterns from successful Web designers, including their own experience in consulting and teaching, and have made this information accessible to all of us. The book is readable yet full of worthwhile information--a valuable addition to any Web designer�fs bookshelf."

-Linda Rising, independent consultant and author of The Patterns Handbook, The Pattern Almanac 2000, and Design Patterns in Communications Software

"[The Design of Sites] bridges the gap from theory to practice and makes it possible for people in the Web-design space to use user-centered design principles in their work�|without having to undertake extensive training."

-Maya Venkatraman, human interface engineer, Sun Microsystems

"The coverage [in The Design of Sites] is excellent--issues go beyond the traditional �edesign the best page�f focus and do a good job of showing the context. I haven�ft seen any other book with the kind of breadth this has."

-Terry Winograd, professor of computer science, Stanford University, and editor of Bringing Design to Software

"With this book as a reference, you can benefit from what companies like Yahoo! have learned and apply it to your site, even if you don�ft have a design and research team similarly sized and staffed."

From the foreword by Irene Au, director of User Experience, Google; former vice president of User Experience and Design, Yahoo!

The Design of Sites, Second Edition, is the definitive reference for the principles, patterns, methodologies, and best practices underlying exceptional Web design. If you are involved in the creation of dynamic Web sites, this book will give you all the necessary tools and techniques to create effortless end-user Web experiences, improve customer satisfaction, and achieve a balanced approach to Web design.

After a comprehensive tutorial covering the foundations of good Web site design, you will move on to discover the thirteen major Web design pattern groups. These patterns solve recurring design problems and help design teams avoid reinventing the wheel. Patterns range from creating a solid navigation framework and the all-important home page, to instilling trust and building credibility with your customers and improving site performance through better design.

The book features

• Coverage of AJAX, the Mobile Web, and online communities
• Seventeen new design patterns to add to the original ninety, including the new blog site type
• More than twenty significantly updated patterns
• 450 four-color screen shots and diagrams, including more than 150 new images
• Key site elements, including site maps, style sheets, dynamic elements, and customer profiles
• Clear, visual organization with color-coded sections for easy reference
• A balanced approach to Web design that takes both customer and business needs into account

If you are looking for a very technical book which outlines the various layouts you can use for a website, this is it. For my purposes, it wasn't very helpful.

I was looking for something to help me improve my design skills and this was definitely not the book. Nothing about design at all.

This book may simply be the best collection of proved successful web interface design patterns. It has no technical details but does has a rich collection of the state of the art patterns that can inspire web designer. Studying this book before actual writing any web interface code is highly recommended.

This book is amazing. It's big, but it needs to be. It comprehensively addresses all of the functional pieces of a website. It defines the problems, expands on the different solutions and offers alternatives and related problems to consider before deciding.

It provides extensive (color-coded) cross-references like a textbook, but does not use the fuddy-duddy language that is expected in textbooks. Easily understood explanations for the concepts fill the text and full color screen shots, illustration and diagrams are commonly included, helping to round out the ideas. It leaves little untouched or undefined.

This is a necessarily large book that should be required reading for anyone embarking into site design.

I bought the Design of Sites book about three months ago and have read about 250 pages of it so far. The book has full-color pages and is a great reference for design decisions. It covers topics for so many different types of web projects. It talks about design, usability, information architecture, and almost all aspects of the web. It isn't meant to be read cover-to-cover, but the amount of great ideas and design solutions it presents make it hard to only read it when you have an issue. Over 800 pages and a great appendix with sample usability evaluations and how to conduct online research will without question make you a better web designer/developer. I can't wait to finish reading it.

I am taking college courses for web design and I keep thinking to myself why they don't make this book a standard for the courses I am taking. This book is a wealth of information on any subject or problem that you might run into in designing a site for the client as well as the user. I may be quite selfish and want to keep the information about this book a secret, that is how good it is. I keep returning to the book over and over again to answer questions for my courses (that the required books) don't explain in detail. I think that says alot about this wonderful book. If you have any hesitations about buying it DON'T.

Pro CSS and HTML Design Patterns is a reference book and a cookbook on how to style web pages using CSS and XHTML. It contains 350 ready�|to�|use patterns (CSS and XHTML code snippets) you can copy and paste into your code. Each pattern can be combined with other patterns to create an unlimited number of solutions.

Each pattern works reliably in all major browsers without the need for browser hacks.

The book shows how to

• Code CSS and XHTML
• Turn HTML into XHTML
• Use CSS Selectors
• Use six CSS Box Models
• Create rounded corners, shadows, gradients, sprites, and transparency
• Replace text with images without affecting accessibility
• Style text with fonts, highlights, decorations, and shadows
• Create flexible, fluid layouts
• Position elements with absolute pixel precision
• Stack elements in layers
• Size, stretch, shrinkwrap, indent, align, and offset elements
• Style tables with borders and alternating striped rows
• Size table columns automatically
• Integrate CSS and JavaScript without embedding JavaScript in XHTML
• Create drop caps, callouts, quotes, and alerts

The book�fs layout, with a pattern�fs example on the left page and its explanation on the right, makes it easy to find a pattern and study it without having to flip between pages. The book is also readable from cover to cover, with topics building carefully upon previous topics.

A software developer can use this book to learn CSS for the first time. A designer familiar with CSS can use this book to master CSS and XHTML. If you are completely new to coding or completely new to CSS and XHTML, you may want to read an introductory book on CSS and XHTML first.

You can interact with all the examples in the book at www.cssDesignPatterns.com.

This is the book to buy for those who want to take it to the next level. So many great thing about this book. If your a novice and want to step-up your design prowess this is the book for you. One review said - "Pro CSS and HTML Design Patterns is just that, a huge guide to each and every HTML and CSS combination you could possibly think of.." I say - very well said.. It's limit-less... I love it!! Wicked!

I found Pro CSS and HTML Design Patterns by Michael Bowers to be of real help in developing drop down buttons for my web dev client. Mr. Bowers makes many complex css styles easy by providing all the formulas. I recommend it highly.Pro CSS and HTML Design Patterns

This is a great book for a number of reasons. Primarily, it's accessible and a quick reference. The book is succinctly written and very well focused.

Each topic is summarized in a small segment. In minutes you can find things if you're totally new to CSS. Likewise, seasoned web developers can find the tricks and techniques that let you exploit your web page development.

Those who understand CSS will find a trove here. One may trudge through other one true holy grail bulletproof designs. They have their place.

Then, leap, at last, into this book. It's been sitting on your bookshelf, perhaps, undeservedly ignored, for a week? You peruse. You find the page for your problem. You read, carefully. A light bulb! "Of course," you may think! Or, "He's telling me, what I SHOULD have known!"

Yes, but, everybody needs SOMEONE to gather these essential prods. Here they are, distilled, a fine essence. Rock solid. No fluff. Problem, stated clearly; solution, stated plainly; sample code, crisp. Just what you need. Terse. Precise.

Hi

I have read about half the book and I find it very interesting and very practical. The book gives you patterns and approaches to solve the problems which designers confront daily. The index is also very helpful at the back, which points me straight to the solution of the problem which I am seeking. When compared to other books, this gives more than what every other book is giving, which I have seen. Generally all CSS books give various properties of the html elements, its possible values etc. While this book, has a different approach. This book discusses the affect of changing these element properties based on the context where the element is placed. It has very good discussion of the box model concept and positioning concepts.

Till now, I have loved this book and has become my reference for all my css needs.

Even the best developers have seen well-intentioned software projects fail -- often because the customer kept changing requirements, and end users didn't know how to use the software you developed. Instead of surrendering to these common problems, let Head First Software Development guide you through the best practices of software development. Before you know it, those failed projects will be a thing of the past.

With its unique visually rich format, this book pulls together the hard lessons learned by expert software developers over the years. You'll gain essential information about each step of the software development lifecycle -- requirements, design, coding, testing, implementing, and maintenance -- and understand why and how different development processes work.

This book is for you if you are:

• Tired of your customers assuming you're psychic. You'll learn not only how to get good requirements, but how to make sure you're always building the software that customers want (even when they're not sure themselves)
• Wondering when the other 15 programmers you need to get your project done on time are going to show up. You'll learn how some very simple scheduling and prioritizing will revolutionize your success rate in developing software.
• Confused about being rational, agile, or a tester. You'll learn not only about the various development methodologies out there, but how to choose a solution that's right for your project.
• Confused because the way you ran your last project worked so well, but failed miserably this time around. You'll learn how to tackle each project individually, combine lessons you've learned on previous projects with cutting-edge development techniques, and end up with great software on every project.

Head First Software Development is here to help you learn in a way that your brain likes... and you'll have a blast along the way. Why pick up hundreds of boring books on the philosophy of this approach or the formal techniques required for that one? Stick with Head First Software Development, and your projects will succeed like never before. Go on, get started... you'll learn and have fun. We promise.

When I first looked at Head First Software Development by Dan Pilone and Russ Miles, I was thinking that it would be best targeted at people who had never formally written software before. It definitely fits that bill. But I can see a use for experienced developers who have never been exposed to agile development techniques. Either way, it's a very good book.

Contents:
Intro
Great Software Development: Pleasing Your Customer
Gathering Requirements: Knowing What The Customer Wants
Project Planning: Planning For Success
User Stories and Tasks: Getting To The Real Work
Good-Enough Design: Getting It Done With Great Design
Version Control: Defensive Development
Building Your Code: Insert Tab A Into Slot B...
Testing and Continuous Integration: Things Fall Apart
Test-Driven Development: Holding Your Code Accountable
Ending An Iteration: It's All Coming Together...
The Next Iteration: If It Ain't Broke... You Still Better Fix It
Bugs: Squashing Bugs Like A Pro
The Real World: Having A Process In Life
Appendix 1 - Leftovers: The Top 5 Things (We Didn't Cover)
Appendix 2 - Techniques and Principles: Tools For The Experienced Software Developer

The authors do a great job of covering the entire software development process, from getting requirements to debugging code. But instead of going back to the older and more traditional waterfall method of software development, they chose to expose the reader to the agile methodology. Personally, I think that's a great decision, as it gets across important techniques such as story cards, iterations, and test-driven development. Learning those skills as the primary way to build software goes a long way towards prepping the new developer for the marketplace.

But as I contemplated this approach, I realized that the content would work for more than just new software developers. There are still a large number of long-time developers who have been raised in the waterfall method. When you start talking about agile techniques, there's a hesitancy to try something so radically different than what they've always done. HF Software Development can serve as that "first exposure" to the agile methods for them. It's no secret that I love the Head First method of teaching, so I'm convinced that the style of writing would also be perfect for absorbing the new information.

It's not often that I find a book that can effectively address two audiences at entirely different ends of the spectrum. But I guess I shouldn't be surprised that it's a Head First book that pulls it off. If you're a new software developer, this will get you started off on the right foot. And if you're an experienced (read: long-time) developer, don't be so quick to dismiss this...

This is my second Head First title. I have enjoyed this one just as much as Head First SQL: Your Brain on SQL -- A Learner's Guide (Head First).

Some people may be put off by the style: images, stories, repetition, etc. I would encourage those people to give it a shot. The content is very well put together, thorough, and interesting.

I will encourage the rest of my team to pick up this book. We will all benefit from the concepts delivered and explained by the Head First team.

I first lend this book from collage developer an have read with great enthusiasms and finally ordered my own copy of this book.
The book gives detailed information on how to developing software from scratch, taken you by hand and leading you de hole way step by step.
With the different way to present the information en with lot of illustrations its newer a boring read.

Anders Kjaer

[...]

Although I was initially put off by the non-serious cover and gimmicky premise, I decided to trust to O'Reilly and give this book a try. That turned out to be a great decision!

Be forewarned that the real title should be "Head First AGILE Software Development," so don't expect other methodologies, but it definitely delivers. Whether you're just beginning to take the plunge into agile development, or you've been sort of trying to do it for a while but don't have a real clear picture of your goal, this is a great book for you.

However, if you've been developing agilely for a while, then what you'll find here isn't much more than a refresher course or reminder of how you should be doing things.

I've been eyeballing the Head First books for a while, specifically the Java and Object-Oriented Analysis & Design. I don't program in Java and I think I understand OOP very well. Because of this, the Head First structure looks to offer a bit less structure - so a good "read as you can" book.

I got this title in a raffle. I'm glad I did. It whetted my appetite for more Head First. Not so much for the content (Which I will review further down) but because it's almost like reading a comic book. Easy, entertaining and something my busy dizzy mind could readily grasp in small chunks. I will probably get another Head First book in the future. Probably more than one.

As for the content of this book, it was well laid out and for someone new to the concepts of formal software design, it was nice to see all the little pieces come together. I did have a hard time with the Java specific environment, but I guess it would be a much larger book if they covered other systems. The steps were clear, some of them a smidge corny, but most of them logical.

After having read this, I was inspired to put it to use. That's when it hit me. I can't see this working unless the entire development group reads the book - or they were all newbies. Well I can see it, just not in the places I've worked.