On the Erskine Labs blog today there's a new post from Wil Linssen with a suggestion to PHP developers who specialize in the language - take the time to learn another language and broaden your skills.

So many languages share fundamental principles, and indeed many are even derived from the same concepts, but because they differ in their approach there's something new to understand in each. It's these differences that will frequently bolster your understanding of your primary language, or indeed of programming as a whole.

He notes that it's not just PHP developers that pigeon hole themselves into one language - developers on other languages do to. He recommends they lift their heads up and branch out and stop attacking other languages with "language X is best" articles.

It's stepping outside of your comfort zone and engaging with the underlying concepts of the languages and tools you are using that will enable you to grow as a developer.

On the Zend Developer Zone there's a recent post from Keith Casey about some of the basics of good OOP design, specifically in following the SOLID principles - a set of five guidelines that make code easier to manage and maintain over time.

As much as we're like to believe that "loose coupling, high cohesion" is enough, when you actually dive into the concept, you find that it's more descriptive than prescriptive. If you want to know how to actually apply these to your day to day development, you have to get into the SOLID principles which describes the five tangible aspects that "good" OO design should contain.

He goes through each of the five principles in the list, describing what they are and, for some, including a bit of sample code to make the point clearer:

• Single Responsibility Principle (SRP)
• Open/Closed Principle (OCP)
• Liskov Substitution Principle (LSP)
• Interface Segregation Principle (ISP)
• Dependency Inversion Principle (DIP)

On DZone.com there's a recent article from Giorgio Sironi about the SOLID set of principles for software development (more on those here) and how some related principles can be applied to namespaced code in PHP.

While studying for the advanced software engineering exam at PoliMi, I discovered there is also a set of principles akin to SOLID for the design of packages, and not only of classes and interfaces. Uncle Bob published them after the SOLID series. Note that package here can be intended as a zip or any deliverable binary unit, not necessarily as a PHP namespace or Java package, or a source folder. [...] In fact, I think that PHP namespaces will play the role of packages soon, as they provide a mechanism for encapsulation: use statements are not necessary when you refer to entities in the same namespace, just like java imports.

These three additional principles (CCA) are:

• CRP: Common Reuse Princple
• CCP: Common Closure Principle
• ADP: Acyclic Dependencies Principle

Check out the rest of the article for their full descriptions.

The NETTUTS website has posted a top ten list of things from the PHP masters out there, a few words of wisdom to live by. Here's the list along with the authors of each:

• Use PHP Only When You Need it - Rasmus Lerdorf
• Use Many Tables With PHP and MYSQL for Scalability - Matt Mullenweg
• Never, ever trust your users - Dave Child
• Invest in PHP Caching - Ben Balbo
• Speed up PHP Development with an IDE, Templates and Snippets - Chad Kieffer
• Make Better Use of PHP's Filter Functions - Joey Sochacki
• Use a PHP Framework - Josh Sharp
• Don't use a PHP Framework - Rasmus Lerdorf
• Use Batch Processing - Jack D. Herrington
• Turn on Error Reporting Immediately - David Cummings

Some of them are conflicting, but that just means that you'll have to do what you've always done - take advice with a grain of salt and ultimately decide what's best for you and your application.

PHPFreaks has posted part one and part two of a new series they're working on to introduce those new to the language to the concepts of object-oriented programming in PHP.

On the old site, I started a series of tutorials named "PHP Application Design". I planned for at least three parts, and while I did publish the first two and wrote at least half of part three, I found myself out of time to make it to the finish. Still dedicated to writing reusable and extensible PHP code and spreading the knowledge, this is a restart of the series, renamed as simply "OO PHP"

In part one he looks at the basics of OOP (terms, defining properties/methods, autoload, exceptions, type hinting, etc) with some code examples sprinkled through out. Part two looks at the "boring OOP principles" like polymorphism, encapsulation and heuristics.