Travis Swicegood has made two blog posts about his agreement with other statements made about why class inheritance sucks.

From the original comments made by Bernard Sumption:

All of the pain caused by inheritance can be traced back to the fact that inheritance forces 'is-a' rather than 'has-a' relationships. If class R2Unit extends Droid, then a R2Unit is-a Droid. If class Jedi contains an instance variable of type Lightsabre, then a Jedi has-a Lightsabre.

Travis agrees and then comes back with his second post to clarify something - composition versus inheritance:

I approach OOP from a flexibility standpoint with one of its biggest flex-points being loose coupling which in turn promotes reusability. I'm going to use Event as a hypothetical example.

He uses Events and design pattern illustrations (like the Visitor and Observer) to help illustrate his point.

DevShed continues their look at handling static data in a dynamic application with the final part of the series - using the observer design pattern to handle the insertion of the static information.

I'll show you how to use a static property, along with the programmatic model dictated by the observer pattern, to implement an expandable data validation system. This task might have an immediate application in a real situation.

They show how to handle user information (as defined as properties in the creation of the user objects) and pushing that data back out into the page. The observer pattern comes into play when they go to validate the user information checking to see if it's all alphabetical, numeric or an email address.

As pointed out by Cal Evans on the Zend Developer Zone, there's a new look at Observers and Dispatchers over on Peter Goodman's blog.

Maybe you've used a framework that uses Observers and Dispatchers, or you've heard of them but don't know how they work. Well, I'm going to explain them and tell you why they're so useful.

He starts with a table defining the parts of this dynamic duo before jumping into the code examples and explainations. His first example is just a basic use of the pattern, while the second involves using a MySQL table for the notification events.

DevShed wraps up its look at the Observer pattern in PHP with this last part of the series - centralizing the data validation of your PHP5 application using the Observer pattern.

Well, over the course of this last tutorial, I'll be moving the application of observer objects toward the real world, in this case by showing you how to include these objects within a set of form-validation classes. After reading this article, you should be equipped with a decent knowledge of how a form checking application can use the powerful features of this widely-known design pattern.

They look back first at the code for the form validation class from the previous article before moving on and building in more functionality - a FormObserver class. Finally, they pair the two classes to make a working, validating example.

Patterns in PHP are becoming more and more popular, and sites like this one are doing well to provide summaries of each with code examples to help clarify.

Following my petty wingeing about the design patterns in php on the web I have to bite the bullet and do something about it. So here it comes a collection of design pattern examples, some from the GOF book, some collected from around the net, some (maybe) I have discovered.

The intent of these pages is to show the shapes of the patterns not a fully fledged implementation. In real life probably a combination of patterns will be employed. Everyone has their own favourites following their political, religious and style differences.

He admits that the pages are a work in progress and aren't complete, but they're a start to share his studies with the world. His list of patterns so far includes:

• Facade
• Hooks
• Protocol Method
• Singleton

with more to come. All of his examples under each pattern are written in PHP.

DevShed continues their look at the Observer pattern in PHP with this new tutorial, part two in the series - developing a form validation system with the Observer pattern.

Well, after refreshing some of the most important points regarding the creation of observer objects, let's focus our attention on the subject of this second tutorial. Over the next few lines, I'll be demonstrating how to apply the Observer pattern during the development of a real-world application: a form validation system.

They start with the creation of the validation classes for the different data formats. They follow it with the creation of a few more, a bit more abstract classes for validation. Finally, they tie it all in, using the Observer pattern to integrate the form data inputted and the routines to check their values.

DevShed is starting off a new series today with the first part of their look at design patterns, specifically this time, the Observer pattern.

If you have reached the point in your programming life where you are using design patterns, you will want to read this article. The first of a three-part series, it covers the Observer pattern, which can be just the thing for situations where objects need to send information to a centralized mechanism.

I hope you'll be wondering how all this boring theory can be translated into functional PHP code. That's what I'm going to do in the course of this article, by introducing some friendly examples of how to implement the Observer pattern in PHP applications.

They just right in and create a more practical example, opting for demonstration over a lot of explaination. Their sample code manipulates strings to change them to uppercase and save them off to a file. They attach a basic error logger to it and then conform it to fit in with the Observer pattern style.

Robert Peake has a new note today about how Part Two of his Design Patterns series has been published in the latest PHP Magazine.

The latest issue of PHP Magazine is now available. In it you will find part two of my series on design patterns in PHP, along with a host of other great articles. Check it out!

In this part of the series, he covers the decorator, strategy, and observer patterns...