The Zend Developer Zone has posted part two of Aldemar Bernal's in-depth look at using the Zend_Acl component of the Zend Framework to manage the access control for your application.

In part one we saw how to setup our Zend_Acl instance and how to attach it to the MVC environment (by using the Front Controller Plugin), but what about setting another action for the denied access, or how does an article be edited only by its owner?, this, and some more is what we are going to see in the following examples.

This second part is broken up into a few parts:

• Using Modules
• Using Roles
• Setting the denied error action
• Using the action helper

These two tutorials are based on this proposal for the integration of Zend_Acl into the current framework is currently pending.

As a part of his "Advancing PHP Developer" series, Eran Galperin has posted part five, a look at design patterns and what they can do for you and your application.

A design pattern is a general reusable solution to a recurring design problem in object-oriented systems. Design patterns are essentially blueprints that suggest how to solve a particular set of OO design problems while adhering to OO best good-practices (which I've recounted in my Object Oriented part of this series).

He talks about one of the most popular examples - the Model/View/Controller design pattern that is used in many rapid development frameworks for PHP (including CodeIgniter and the Zend Framework). He also briefly mentions a few others like the composite, singleton and decorator patterns.

Other parts of this series include looks at testing, refactoring and coding standards.

Recently the eZ Systems group had their eZ Awards ceremony at this year's Open Nordic Conference 2008. Derick Rethans has a brief post about the ceremony and the nominees/winner of the eZ Components award.

Last Thursday, during the Open Nordic Conference 2008 eZ Systems handed out its annual awards again. For the eZ Components award, there were four nominees, which are all recognised for their support of the eZ Components project.

Nominees included Stefan Marr and Falko Menge, James Pic, Andreas Schamberger and Freddie Witherden. The winner was James Pic for his work with the upcoming MVC additions to the component framework.

The Zend Developer Zone has posted a new tutorial (from Aldemar Bernal) about some of the basic use of the Zend_Acl component of the Zend Framework.

So, what is wrong with Zend_Acl and the current MVC implementation in the Zend Framework? there is nothing wrong, it is just that it gets not too obvious for developers how to achieve an optimal integration between these two important parts of the framework.

He talks about the proposal that's out for a potential update to the component, the two key points being the front controller plugin and a new action helper. He includes some sample code showing how to set it all up including a "denied" controller to handle the failures.

Bill Karwin (formerly of Zend and the Zend Framework project) has a new post to his blog defending one of the more abused (both in code and in opinions) design patterns, ActiveRecord:

ActiveRecord is fine. It is a tool that does just what it's designed to do. What sucks is when developers try to make it do other things than what it's intended to do.

He cites his work with the Zend_Db component and how Mike Seth gets it right when he says that the pattern shouldn't be "ActiveRecord-View-Controller". He compares the ideas of a true Model in an MVC application with the incorrect ideas that many developers seem to hold.

A Model is a class that provides a logical component of your application domain. Models are products of OO design, which is a development activity I see get very little attention in the developer blogosphere or the developer tools market.

Models can reference one or many (or no) database tables and are not where the hard work is being done. That's saved for the ORM (or ActiveRecord) to do.

In a recent post to the Ask About PHP blog, there's a quick "first look" at the CakePHP framework from a beginner's perspective.

Finally, I found some time to take CakePHP for a spin. I've heard some really good things about it, and I've been trying to get some time to try it out. I installed the framework and went through the tutorial on building a simple blog application. I have to say I'm quite impressed.

The post briefly introduces the Model-View-Controller method the framework follows and shows some of the features/benefits it brings with it - the low entry level, its speed, and whether or not it makes for a good "first framework" for other developers.

Michael is back with part three of his series stepping you through the creation of your own MVC framework (Part 1 and Part 2) with a look at the part that interfaces with the user - the View.

Using the view as a starting point may seem odd at first considering the view-related actions are some of the last steps in the page load scenario, but since our views don't have any external dependencies, unit tests are very easy to write and so is the accompanying code.

He explains how views work along with the rest of the framework and some of the basic rules surrounding how they get their data. Code comes along with the explanations for different views like XML, HTML and JSON methods of output.

In this new post to his blog today, Padraic Brady continues his series looking at developing a blog with the Zend Framework. He moves on to look at the MVC structure behind the application in this latest post.

After speaking with any number of users about getting started with a framework, I find many do not have an advanced understanding of the corner stone of a current day web application framework: the Model-View-Controller Design Pattern.

He explains the normal development approach (kind of a Page Controller where each bit of functionality has its own page) versus the Model/View/Controller approach of separation of presentation and logic in a structured fashion. He also goes through each of the parts of the MVC equation and shows the difference between the roles that the Controller and Model have in the application.

Michael Girouard has posted his 10,00 foot view of the typical structure of an Model/View/Controller application (and framework) and how a page request is handled:

In my previous article, I announced that I would be documenting the process of developing a simple MVC framework. In this post I will go into a little more detail about each of the specific components of our MVC and will discuss the series of events which occur each time a page loads, otherwise known as the page load scenario.

He talks about how URIs work, the role of mod_rewrite, several of the objects involved (like the Front Controller, Request, Route and View) and how they all fit in with the custom Models, Views and Controllers the user could define.

Stefan Mischook has posted the second part of the video tutorial introduction to making a Zend Framework application:

This Zend Framework video is from our resident Zend-nerd: Jon Lebensold. Again, let us know what you think and should you have any suggestions or request, please feel free to comment.

Part one was posted back on Tuesday for those that need to catch up.