In your development time, you might have heard of the SOLID development design principles that aim to keep you and your application well structured and on track. If you haven't had the time to learn much about them, you should consider this new post from Pim Elshoff that briefly covers each principle (with some code examples along the way).

Oh how we love acronyms. We've discussed a lot about writing a class, but we haven't talked about writing classes yet. How do you know if your solution is right? It is not enough to have a working program. SOLID is a set of principles that define severable measurable properties your architecture should have at least, in order to be dubbed right.

He goes through each of the principles (single responsibility principle, Liskov substitution principle, etc) and gives a summary statement, a definition and code illustrating it in use. The examples aren't all based on the same code as implementing all of these principles at once as been found to be difficult. He also includes another principle to keep in mind - the "Law of Demeter" dealing with calling scope of properties and methods.

On Query7.com today they've posted the first in a series looking at frameworks that are more PHP 5.3 centric. They start things off with a very popular framework that currently has a major update in the works - Symfony2.

Ever since PHP5.3 was released we have seen several new frameworks pop up in the PHP community. In this series of articles we will look at and evaluate some of the next generation PHP frameworks. Today we look at Symfony2.

He starts with an overview of what the framework has to offer - things like the expected MVC structure, database integration with Doctrine2 and templating with Twig - as well as its heavy use of dependency injection. He also mentions its ability to use PHP, XML or YAML for configuration files as well as other features like bundles, large support for testing and built-in HTTP caching. He also briefly mentions something that is the heart and soul of any open source project - its community.

On the Query7 blog there's a recent post introducing you to the Kohana PHP-based framework (Kohana3, to be exact) and its setup.

This is a brief introduction into the Kohana framework. The next two tutorials will cover how to build a blog in Kohana. [...] Installing Kohana is very straight forward, just download the latest stable version of Kohana and unzip it. No need to mess around with yaml or xml files like other frameworks.

The installation gives you a set of environment tests that run to ensure your environment is set up correctly. If it's not, instructions on how to fix things are included. They also talk about the filesystem structure and where you can find the configuration settings if you'd like to change them away from the default. There's also mention of the support the framework has for modules - basic packages that can be easily included as needed for things like database functionality, OAuth support and unit testing interfaces.

Daniel Krook has taken a look at the Zend Server tool and has written up a post that's part description and part tutorial. He talks about features of the Server and offers some helpful hints for getting it up and running.

A few months back, Ed Kietlinski introduced us to the new Zend Server at a New York PHP meeting. I've since installed it on two of my department's servers and put together some notes on my experience.

He takes a look at what the Server is and what it has to offer, both for corporate and community projects. He also notes that it has hit the "sweet spot" in his group to provide an easy to maintain solution that gives them all the power and simplicity that a package-based too can provide. He spends the rest of the post showing a sample installation onto two CentOS servers (including the installation of DB2, Mail and PEAR).

New from the Web Developer's Virtual Library today is this overview by Marc Plotz of the Zend Framework, including a brief introduction to the Model/View/Controller design pattern.

Many developers are scared off by the thought of something as huge and confusing as the Zend Framework - I know this because I was once one of them. What I soon learned was that there is some pleasure in working with a framework that does most of the nauseating grind work for you. However, there is a trade off: you have to understand the somewhat pedantic nature of the code required along with the principles of the design pattern that is MVC (Model-View-Controller). Is it worth it? Let's take a look.

The article takes a very high level look at the framework mentioning the bootstrapping the framework does ("not only safe, it makes sense") and a look at one of the many components the framework comes with - Zend_Mail.

From BuildInternet.com today there's a new article from Jason Gilmore looking at PHP frameworks and why they matter to both the developers and the community at large.

Having been a PHP programmer for more than a decade, I've come to realize that many of my fellow PHP programmers seem to have a misplaced notion of what being "lazy" is really all about. [...] Suddenly the Web developer was facing so much more than validating user input and connecting to a database [and] the need to be a lazy programmer was more important than ever.

He covers a lot of the basics of frameworks with a focus on the Zend Framework (because of familiarity) - configuration, data validation tools, database connections, display helpers and the inclusion of third-party plugins.

In this new article from Noupe.com they look at a hot topic in the PHP community - frameworks - and give an overview of the features of five popular choices.

PHP is the world's most popular scripting language for many different reasons - flexibility, ease-of-use, among others - but often times coding in PHP, or any language for that matter, can get rather monotonous and repetitive. That's where a PHP framework can help. [...] Frameworks can also help beginners to build more stable apps by ensuring proper database interaction and coding on the presentation layer. This allows you to spend more time creating the actual web application, instead of spending time writing repetitive code.

They touch on why you should use a framework and when are appropriate times to make them a part of your development. They also point out a few common mistakes that are often made when using frameworks like using a framework above your skill level or ensuring that all other technologies will work with your framework of choice.

They finish the article off with a look at the features of five different frameworks:

• Zend Framework
• CakePHP
• Symfony
• CodeIgniter
• Seagull

Ray Cheung posted his comparison of the Zend Framework and CakePHP a little while back to share some of the thoughts and research he did to pick one over the other for his application.

A lot of people have been asking for some comparison articles for some of the popular frameworks. [...] Overall, both these frameworks are good to use as per your requirements. CakePHP is suitable for developers new to MVC and those who require stricter conventions. ZF is a choice for those who need better control over the application design and built-in support for renowned Web services. Both the frameworks are developing fast and the choice is entirely yours.

He includes brief overviews of each framework and comments on documentation and configuration issues surrounding them.

Commentors on the post include Nate Abele (of CakePHP) and Wil Sinclair (of the Zend Framework).

Alvaro has put together a post that lays out some of the design patterns that the Symfony framework uses to get the job done:

Much has been said this days about how modern web frameworks interpret the MVC architectural pattern. I'm my case those articles made me rethink how I use a framework, specially Symfony. This lead me to start a study on which patterns come into play while we develop a Symfony application. So while adding new features or refactoring existing ones I will know which class is in charge off doing the job.

Some of the design patterns mentioned include the Front Controller, Contaxt Object, Helper Object, Active Record and Single Table Inheritance. He includes brief examples of each of them in use (no code but plenty of description).

On DevShed there's a new tutorial looking at user management in a PHP application including looks at data validation and encrypting passwords.

In this article we will look at how to create a secure user management module. No user authentication or user management script can ever be one hundred percent secure, but we can try to use the tools that are available to us to their maximum, and thereby make it difficult for malicious users to hack our scripts.

They include example scripts showing how to validate user input - length, alpha, empty or not and if its numeric or not. They look at encryption with the sha1() technique, comparing the user's input, hashed, to the key already stored.