PHP 5 Objects, Patterns, and Practice

• #10 in Best PHP Books

30 Reviews

Sort by: Most Helpful ▲ Date Rating

Fact of the matter is that PHP5 is a serious enterprise level development system. This book takes it seriously and presents both practical and architectural material at a level that used to be reserved for J2EE and .NET works. This relatively short book is packed full of well written and insightful content. It stars with the basics of PHP5 OO programming with detail about the mistakes in PHP4 that have now been rectified. That is taken all the way through advanced topics like reflection.

The author then switches gears and gets into the design of object oriented applications. Now that we have the right tools, how we should use them to make better systems, right? UML is covered, and so are design patterns.

The later chapters of the book cover solid software engineering practices, like version control and unit testing, amongst other.

Not only will this book give you new ideas at a coding level, it will also open your mind as an engineer and get you headed in a direction toward architecture and large scale application design.

An excellent book. A must have for any serious PHP developer.

I haven't read a book on PHP in ages. In fact, I haven't programmed in PHP since 2001. With this in mind, I can say that Matt Zandstra's "PHP 5 Objects, Patterns, and Practice" was a very approachable introduction to what the latest version of the PHP platform has to offer to an OO developer from the Java scene.

The book is split to three main sections: objects, patterns, practice. The first section runs through the new object-oriented features of PHP 5, the second sections introduces design patterns and includes a catalog of some of the more common patterns from the original Gang of Four patterns as well as from "Core J2EE Patterns". The third section is a set of tutorials on tools and assets that a modern day PHP developer really should know about and make use of: the PEAR installation tool, PhpDocumentor, and the Phing build tool. The author also squeezed in a bit about the PHPUnit2 library for unit testing PHP code which I especially appreciated.

The design patterns catalog is far from comprehensive, covering only a small subset of published design patterns in the Java/.NET camps, but serves its purpose alright. Every included pattern is illustrated with an example that the author has crafted for the PHP context - in other words, these are not just direct ports from their Java equivalents, for example.

While being an easy read, Zandstra's introduction to the object-oriented features is, I believe, perfectly adequate to get started with object-oriented PHP programming. Combined with the discussion about design patterns, the book feels like a valuable asset for getting up to speed after a break. A more up-to-date PHP developer might find the information a bit lacking but for someone new to PHP 5's object-oriented features, this is a good package to get started with.

I liked this book. It is probably the first I have run across that treats PHP as a serious development environment, addressing it to enterprise level tasks. That said, let me add a cautionary warning, this book is not for the novice to OOP.

Mr. Zandstra approaches his task by dividing the content into three sections: 1) Objects - covering various basic and advanced concepts in OOP as they apply to PHP, from polymorphism and encapsulation to abstracts, error handling and interfaces, 2) Patterns - using a few sources (including the 'Gang of Four') he covers composition, object generation, tasks and layers among other topics, 3) Practices - offering a little advice on how and why to use patterns and standards, as well as some coverage of PEAR, documenting and version control.

From a practical standpoint, I found the book interesting, but somewhat overwhelming. Let me try to clarify that a little. This book is targeted at enterprise level development, meaning serious business level coding/development. Most of my work in PHP so far, while it makes use of OOP, is relatively small scale (15-20 classes ranging from 200-1500 lines each in my most complex site). While I can see the logic in the patterns and practices that Zandstra writes about, the overall content is overkill for my scale of project. Now that isn't to say that I found the book useless, there are many of the concepts that the author discusses that will find their way into my design and code; I just won't be doing a wholesale pattern refactoring of my code (a viewpoint I get the feeling the author would agree with).

If you are a professional developer, I would recommend this book as a good read and part of your PHP reference library. If you are not an enterprise level developer and are just looking for sample code to help solve or implement solutions I would recommend PHP 5 Recipes (Apress).

I got this book thinking, "Hey, this might help me get a leg up on that new PHP 5 OOP stuff." That it did.

However, this book accomplishes much more than that. Zandstra sets himself a several goals and meets them all quite well. These include: providing an understanding of classes, objects, and interfaces in PHP 5; presenting a numbers of useful design patterns as expressed in PHP 5 terms; giving the reader information about and insight into advanced development tools and methodologies for large-scale PHP 5 projects.

A particularly valuable service provided by the author lies in the fact that there is a real dearth of material on design patterns for PHP developers, most of the literature on this subject being written with the assumption that the reader is highly proficient in Java or C++ (or possibly Smalltalk). This is all well and good if your background includes lots of work or study in one or more of these; however, for many Web developers, PHP is the primary and sometimes only programming language (and for many more, their only previous experience is with other scripting languages such as Perl, Python, JavaScript, VBScript, etc.). Zandstra goes to the effort of translating many of the classic "Gang of Four" design patterns into PHP 5 code and thereby makes accessible a realm that was heretofore unknown to many PHP developers.

If this were all that the book covered, it would be useful in and of itself for this alone. But the author also gives us a good, thorough grounding in both the mechanics of PHP 5's new object model and (especially important!) the rationale behind it. He also provides a nice tutorial on UML modeling along the way, and finishes up with a look at some current development tools like Phing and CVS. There are plenty of helpful and useful examples along the way.

I give this book 5 stars for having really helped me wrap my head round some advanced OO programming and design concepts. I've already got loads of use from it; my copy is about two months old, and it's already getting dog-eared. It's also a very enjoyable read, and a real cut above most of the "How To Program In ..." sorts of books. This is the perfect book for someone with some experience with writing PHP code who's looking to move up to the next level - creating real, scalable, enterprise-level PHP applications.

I'm already reasonably educated on basic patterns. However, I did like this book. It was a good read. I'd highly suggest it for anyone writing PHP and needs to grasp OO development.

However, I was expecting a little bit more in the "Practice" section of this book. I was expecting a few more real world examples to show how the author would use patterns or even Object Oriented PHP in a real world application.

Since there are so few well designed OO PHP projects out there, I was hoping to see something that was specifically OO (as OO as PHP can be anyway) practice... A quick form based multi-page site would have been nice. While that may sound like a lot, it shouldn't take more than 1 chapter (about 30 pages) to show the code and briefly go over it.

So, all-in-all, this book is a great tutorial on PHP OO design. What it lacked (for me anyway), was real world examples of good OO design.

As languages which were not originally object oriented grow in popularity, there is sometimes a trend to upgrade them, by adding in this functionality. C++ can be regarded as an upgrade of C, in this respect. Or how Visual Basic now as VB.NET has quite impressive OO features. So Zandstra's book attests to this trend and to the popularity of PHP. It describes how the OO enhancements in PHP 4 were extended into version 5. You are shown how to use objects to the full extent allowed in PHP 5.

The book is also aimed at a reader who might never have formally learnt to use objects or design patterns. In the last 15 years, these have been two very important ideas in programming, independent of the languages used. Which gives us another merit of the book. You are not just learning PHP 5, though that may be good in itself. By understanding and using the book's ideas, you should be able to apply these in other languages. A valuable increase of your skill set and hence marketability.

You should also read carefully the section on bad practices. Sometimes, just being able to avoid these in your code may be enough to produce a successful program.

It's a good book worth the reading for every programmer aspiring to be a professional. My only negative comment is that I wish the author presented a logical explanation of the reasoning behind pattern implementations before presenting the actual implementation (code). On many occassions I found myself confused as to why a certain implementation was chosen. I understood the code, but did not comprehend the reasoning behind the code. In many cases, the logic of the pattern was not self-evident (for example read the Observer Pattern).

This was the exact right book at the right time for me. I have been managing a php software project for the past 5 years and it's growing harder to deal with. I had started to make some haphazard use of design patterns, cvs, and pear already. It's hard to find time away from daily business pressures to improve one's practices, but this book brought together some very useful techniques and tools in a concise way. I've read patterns books for other languages, but having the examples in php with special attention to php 5's oo improvements made this one much more useful and quicker to absorb for me.

If you are a programmer of any language that supports Objects, this book is for you. This is one of the most clear introduction to all aspects of object design programming I saw so far for a programming language. This is not a "cookbook" with Php recipes, it is a really well written guide to proper software architecture design with Php. So good that you'll find useful also for other languages. Almost all advanced topics regarding Php5 are also covered. Really useful the practices section. PHP developers: please READ! You know, Data Types actually exist! A must have!

Being from a C++ and Java backround, objects have always been second nature to me. This book does a great job of covering the basics of working with objects in PHP 5, but more important than that, it also teaches why we should use objects. By combining theories of Pattern and Practice with the technical implementation details of object oriented programming, Zandstra has exceeded my expectations by offering a new way to look at solving many of the problems I often face as a web developer. His well-seasoned advice draws from a sophisticated pool of experience, and covers a wide range of topics from Project Management to Design Strategy. This has truly proved a valuable resource.

The author of this book assumes a basic understanding of the PHP language and focuses on how to take advantage of the new features of PHP5. The book includes best practices, tools, and principles on how best to write, document and implement a project.

The three primary divisions of the book follow along with the title and are sequenced as Objects, Patterns, and Practice. The Objects section covers the history of PHP and how it evolved to include a focus on object-oriented programming. This section contains some of the more basic information in the book including the principles behind objects, classes and inheritance. The section on Patterns examines problems of software design and ways to approach and resolve these problems. In this section the reader learns basic design principles that should be implemented on all projects to make them easier to troubleshoot or expand on later. The last section covers the practices and tools that can be used to correctly manage a project. The focus is on managing your code, managing your project, tracking bugs, collaboration between programmers, and making the project easy to install. It includes a section on Concurrent Versions System (CVS) which allows multiple programmers to work on the same code without overwriting each other's work.

Although it assumes some knowledge of PHP programming it does not assume any knowledge of object-oriented programming and that appears to be one of the primary purposes of the book - to take PHP4 programmers and teach them to take advantage of the abilities of PHP5. This is not to say that you can't get a lot of value from the book without prior knowledge of PHP. If you have programmed before and have a basic PHP syntax reference guide available then this book will still be a valuable read. PHP 5 Objects, Patterns, and Practice is highly recommended for PHP programmers making the move to PHP5 and PHP5 programmers that need a handle on best practices.

This book does exactly what it advertises; it gives a somewhat comprehensive introduction to concepts of object oriented development in PHP5. It's written in a simple and accessible tone yet never dumbs the subject down. It also clearly states that it offers no complete solutions, only introductions to concepts, though the book tells you where to look for more information.

Coupled with a more complete design pattern catalogue and some more extensive reading on the practical aspects that are not touched on much (Phing, PEAR, CVS/SubVersion, and so on) this book is perfect for the budding PHP developer who wants to learn more than looping over a databse result or doing simple math.

ok; so, you've been reading object-oriented theory (and syntax etc.) for ages. But have all those other books and articles still left you wondering how to put it all together ... and actually implement something? Well, this is THE book ... that shows you how to transition from theory to practice - the CORRECT way(s) i.e. according to the "best practices" of our time.

It's written very clearly and succinctly (which is more than I can say for most other writings on the subjects of objects, patterns & practices). I've seen whole books written (never mind LONG articles) on patterns, that the author covers in a few pages. It takes someone gifted to do that; it is only when one has a commanding and comprehensive knowledge of a subject that one can summarize it in a few words ... and provide examples that leave you thinking ... "ok, I can do that, too (now, that I "get it"). That's the feeling, you're left with ... after this.

Full object orientation has been awhile in coming to PHP ... and this book couldn't have arrived at a better time. I'm delighted, made much more confident ... and inspired by it.

GET IT ... or you will be the loser for not having done so!

The first quarter of this book is an excellent primer on what's new and different in PHP5's objects; much better than the terse, incomplete, and often times grammatically broken, descriptions one finds in the free online documentation. The remaining three quarters, while generally well written when you look at individual segments, commit the most heinous of errors the author strives to warn against: repetition. It seems like every other page contains a "Gang of Four" reference, complete with a thorough description of who the "Gang of Four" are and what the "Gang of Four" did and all the various reasons why you should run out and buy the "Gang of Four's" book instead of this one. By the fourth captioned pull-quote I just wanted to strangle the editor for allowing this to go to press. Once is enough, thank you.

Learning PHP is easy and rewarding, but as your software grows you will need to know how to manage your code, work as a team, and break your problems down into well defined abstractions. This book gathers together all the tools you need in around 400 pages. Not too long considering its scope. It's a practical guide with an easy style that gets straight to the point. It's a great introduction not just to PHP 5 but to object oriented methods in general. If you're just getting started, or if you're an old hand and want to see how large scale applications can be written in PHP, I recommend you read this book.

Despite having read widely both online and off about the use of design patterns with PHP, I've usually been left unsatisfied. Most works on the subject are either too theoretical (and I'm a theory nut) or too rudimentary for those of us who are seeking a deep understanding but also need to employ these techniques quickly.

This book provided a pleasant contrast, providing detail of how to translate its theoretical examples into practical code and pre-empting many of my "yes, but..." moments. As a regular user of PHP5's OO features much of the introductory material was redundant for me, but it was a good summary and is moved quickly out of the way.

I'm recommending this book to other coders I'm working with, particularly those new to OO concepts, and still refer to it regularly.

This book is a great theory book for intermediate to advanced PHP. It skips over beginning PHP syntax and dives straight into OOP. The book is divided into 3 main parts - Object-Oriented Programming, Design Patterns, and Practice.

The OOP part of the book is a thorough covering of OOP from a PHP angle. It spends a little time discussing procedural vs. OO code, but assumes the reader is already convinced of the merits of OOP. It covers all the most important PHP OO ground quickly, but still explains each part in good detail - from the basics of Classes, Objects, and Inheritance up to and including OO design decisions, Polymorphism, and UML. This part of the book is, IMO, worth the purchase price for the succinct yet thorough coverage of PHP-slanted Object-Oriented Programming.

Part 2 of the book is a bit more verbose, as the subject content demands. It introduces the idea of Design Patterns first and goes over some design pattern principles. Then it jumps into the low-level design patterns for handling objects and their relationships, and representing tasks as objects. The last chapter in this part is called "Enterprise Patterns" but it somehow fails to adequately cover the King of Compound Design Patterns - MVC. The "Enterprise Patterns" are instead a PHP translation of a few J2EE design patterns. While this part of the book is very useful for solid PHP programmers beginning to approach Design Patterns, it is theory-heavy and shouldn't be used as a reference point for implementation of the patterns.

The last part of the book covers some useful PHP tools like PEAR, phpDocumentor, CVS and Phing. While these are all good tools, I was disappointed not to see Subversion or PHPUnit covered in more detail.

Each part of the book could be read independently of the others. It is a great theory book, but its ad-hoc and highly-specific code examples make it less useful as a reference. It's easy-to-read and concise style through-out mean you can simply read thru it to quickly and easily learn the theory without a computer on-hand, which is very helpful, too.

great book. clear and well written intro to objects. removes the mystery from the subject and puts it into good English. cheers!

If your PHP is rusty from extended non-use (like mine these days) or if you are still new to PHP, this book can lose you. In chapter 4 the author assumes you are current with the PEAR database classes and throws out an example with no explanation of the code. If this book aims to help you become an advanced PHP coder, then it fails because it assumes you already are one. In my opinion, the book moves to fast and skips over to much explanation to be a good book to learn by, and is obviously not a reference book. I'm sure Zandstra knows his subject, he just needs to sharpen his teaching skills. 4 Stars for knowledge, 1 star for explanation & teaching.

i enjoyed reading the book and learned a lot though i consider myself as an expierenced php programmer. basic and advanced stuff together with a balanced mixture. patterns make programming complex software architectures easier.

Apress publishes some great books (definitely check out Pro JavaScript Techniques and Pro JavaScript Design Patterns if you're working with AJAX). This book definitely lives up to that high standard.

The first part of the book provides a concise but very informative treatment of PHP5's object-oriented functionality, providing some valuable context for those less familiar with OO and demonstrating some of the more exotic features for veterans.

After discussing what patterns are, why they're useful, and some of their basic principles, the book then dives into the patterns themselves. Each pattern is presented according to a standard format: The Problem (what architectural nightmare you're trying to escape from), Implementation (the structure of the pattern, with plenty of explanation and sample code), and Consequences (the advantages and disadvantages of the pattern in various situations).

For the most part, the patterns are presented in a sensible order, starting with more basic patterns, and moving on to more complex ones which build on those concepts. Where appropriate, the book introduces a pattern with less-than-optimal code, and then shows you how to refactor it to improve the pattern. This way, you understand *why* the patterns are designed in particular (and sometimes less-than-intuitive) ways. In essence, you're starting with sloppy code, and then working through a series of refactorings to get the pattern to emerge.

All the usual suspects are here: Singleton, Factory, Composite, Decorator, Facade, Strategy, Observer, Visitor, Command, etc. The writing is clear and to-the-point, uses good examples (with a few exceptions), and addresses possible points of confusion from the get-go. Throughout, the basic pattern principles are emphasized and reinforced, especially when you've just seen an example that exemplifies them.

To be honest, I haven't finished the book--I'm on chapter 12 (Enterprise Patterns, which covers MVC)--but I've already learned so much that I have no qualms giving this a five-star review.

I have noticed a few errors in the code examples (mostly typos--misnamed methods and the like), but as long as you're paying attention to the text, you'll be able to spot them, and this has probably been fixed in the second edition.

By the way, don't pay the going rate in the Amazon Marketplace for this first edition--you can get the second edition for ten bucks cheaper.

I bought this book because I wanted to get a quick start into PHP5 and I had heard of patterns and thought that I could mess around with patterns as I learned PHP5. In the following, note that web-development is just my hobby, not my job.

OMG... I have found religion. My previous attempt at coding up a large website was one that a friend and I coded up 7 years ago with PHP2/3 which was crushed under its own weight and we quickly reached a point that we could not progress any further without breaking something. What Matt does in this book is to bring together many different ways of approaching enterprise and other common PHP problems as far as how do you represent/create/organize data objects in your PHP program and how do you organize program and customer flow.

At first, I approached the "Practice" portion of the book as an afterthought, but have since learned that rigorous testing and test cases saves your behind as I have broken my code in unexpected ways multiple times which I would never have caught had I not followed the advice presented in this book. There are lots of other good hints on how to conduct the business of coding which will save you lots of time in this "Practice" section.

My only gripe with the book was that the learning curve was steep in the "Patterns" section as the examples were interwoven and built highly upon eachother. This required me to go through the book a couple times before I actually understood everything... But this may just be an artifact of my slow brain which has not had any real deep foray into any programming for about 5 years.

This book opened my eyes to a whole new world of programming. Thank You Matt!

Its probably one of the best books for understanding php5 concepts. It describes each and every feature of php5 with appropriate examples and is quite easy to comprehend.

The book gives an excellent introduction in object oriented programming (OOP), even when you want to learn OOP without using PHP. They first describe a clear problem and then show why and how OOP can be used to create a better solution.
(Note that I already had OOP Java knowledge before reading the book.)

The second part of the book focuses on Design Patterns, which I sometimes found not clearly explained; problems unclear and definitions not explained. The OOP part was clearer.

The last part focuses on external tools to ease php programming, like testing, documenting, automatic deploying etc.

A major problem about the book is that it focuses a lot on OOP and design patterns without simply showing how this can be directly applied on a webpage or website. The end of part II feels more like how to make a complete PHP Enterprise framework from scratch yourself, with a lot of details making it a bit hard to crasp. It will take a lot of (initial) effort if you want to apply the enterprise patterns described in this book. In a real project, you probably won't even make a complete framework like this yourself, but take an existing framework like CakePHP of Zend Framework, something where the book doesn't talk about....

This book does borrow heavily from the "Gang of Four" book as other reviewers have mentioned. But the latter is the definative book on Design Patterns.

I would recommend buying both books as they do complement each other quite well. The examples in "PHP 5 Objects, Patterns, and Practice" tended be be a bit obscure but were clear and practical.

I recommend this book.

Zandstra has created a masterful overview of OO for PHP and provides the patterns to go with it. However, the code presented in a number of sections is far from self-documenting, particularly the Enterprise patterns section. A really great additional feature would have been to tie up, broadly, how the patterns interact with one another at various layers of enterprise design; as the book is written, it becomes hard to keep track of all of the objects Zandstra has created over the chapter, and many times he generates a new version of an old object without presenting a full overview of the newer version, making it difficult to see what his revision has actually done. A good example of this is during the ApplicationController pattern, when he rewrites the FrontController object.

I appreciate the practical examples presented throughout, however, and the sections on UML, OO and Practice will very definitely help novice to intermediate designers.

Overall a very nice book. Certainly not a replacement for either "Gang of Four", OO design and PHP books, but a nice compilation. Don't expect any ground breaking strategies or patters. Good book for a person who wants to know HOW to use patters specifically for PHP. Pretty vague on WHY.

If you want to take your PHP coding up to the next level (object oriented), this is the book for you. It has become my primary source for PHP object design concepts.

This is a great resource for learning the Object oriented aspects of PHP and how to use the various design patterns. I have learned a lot of useful information using this book.

Great book, I wish that there was a little more time spent on the first two sections (Patterns and Practice) as I am already familiar with and use the tools presented in the latter chapters. If you are new to working with PHP5 in a more serious development environment and want to expand your skills beyond just creating web pages then this book is worth a look.