William Sanders - Learning PHP Design Patterns

Beijing Cambridge Farnham Kln Sebastopol Tokyo

In memory of my father, William B. Sanders (19172012).

If you purchased this ebook directly from oreilly.com, you have the following benefits:

If you purchased this ebook from another retailer, you can upgrade your ebook to take advantage of all these benefits for just $4.99. to access your ebook upgrade.

Please note that upgrade offers are not available from sample content.

As PHP expands to become the server-side program of choice among a significant portion of programmers, professional techniques and programming structures need to be incorporated. Design patterns , a concept borrowed from The Timeless Way of Building by Christopher Alexander (Oxford University Press), refers to a general reusable solution to a commonly occurring problem within a given context . In everyday development work, PHP programmers encounter commonly occurring problems in a software development context, and the use of PHP design patterns is a set of solutions to commonly occurring PHP programming problems. Pure and simple, PHP design patterns are tools used to deal with the reality of professional software development.

They are not libraries or templates but rather more general structures that can be used to solve problems. I like to think of design patterns in the same way as I do the loop structure. The loop is used when some kind of iteration is required. True, there are other ways to deal with iteration, but a loop is a flexible tool that saves time in the development process. (Besides, its a lot neater than writing the same line of code 10,000 times!)

Further, I do not feel constrained by design patterns as canned solutions any more than a loop is a canned solution to iteration. Besides, I can use the loop structure in a variety of ways in PHP ranging from for to while statements and everything in between. Likewise, design patterns can be implemented in more than one way depending on the exact nature of the problem being solved.

The most important reason for incorporating design patterns, though, is that they provide solutions to complex problems. As ones programs become larger, they almost necessarily become more complex. In an object-oriented programming (OOP) environment, such complexity is reduced somewhat, as you are dealing with encapsulated modules, whereas in sequential or procedural programming, any changes can bring the program crashing down like a house of cards. Design patterns bring not only solutions to general programming problems, but they also allow changes to be made in large complex programs by providing loose coupling between objects. So when a change is made, instead of having to start programming all over from scratch, you can just add the necessary changes and everything keeps chugging alongeven in large, complex programs.

Further, design patterns are meant for reuse. After all, programmers reuse the same algorithms all the time. Why not use larger structures as well? On the one hand, frameworks and templates serve to make reuse practical, but they are often too specific. Thats where reuse of design-patterned PHP programs comes in, especially in the case of large, complex programs. Because making changes is easy with design patterns, reuse for specific problems of the same kind is easy as well. Reducing developmental time and resources saves money and better serves your clients. They get well-structured programs that do what the clients want, theyre easy for the developers to change (customers always want change!), and they have strong foundations that are not as likely to fail.