On the PHPClasses.org blog today Manuel Lemos has posted a look at ORM - what it is and how you can use it to improve your applications.

Object-Relational Mapping, usually referred as ORM, is a software development approach to treat data stored in relational (SQL) database table records as if they were objects. Basically we can create classes with variables that represent fields of a database table. To insert a table record you need to create an object of the class, assign the variable values, and call a function of the class that takes care of inserting the table record

He illustrates what it is (brief code samples) and some of the approaches that developers have taken to implementing it. He suggests, however, that they should truely be called ROM (Relational Object Mapping) libraries rather than ORM due to the fact that they map an object (the database tables) back in to PHP objects. He finishes with a list of a few ORM resources and libraries including the one that helps power the PHPClasses website, Metastorage.

The Midstride Solutions blog has posted five tips and tools that can help to make you a better developer (and possibly make you a faster one).

In this post, I will discuss 5 tips and tools that the php community has provided to speed up development time and improve code quality. These should help you out if you don't already know them, but if you do I would like to hear what you use to speed up your development time.

Their five tips/tools are:

• Framework with the Model View Controller (MVC)
• AJAX Frameworks
• Integrated Development Environment (IDE)
• Database Creation/Management Software
• Object Relational Mapping (ORM)

Included for each is his personal preference and recommendation.

In this new post to his blog Stefan Koopmanschap looks at a plugin for the symfony framework that has him impressed.

Using this plugin, it is not necessary anymore to really care about which ORM you pick for your project. It's the thought behind symfony 1.1 taken into the symfony ORM-selection.

He points to the DbFinderPlugin as an alternative to rewriting up the ORM code for your application by hand (or in something like Propel or Doctrine). It makes switching between ORM layers simple - just a configuration change to point to the new system.

On the Ibuildings blogs, there's a new post from Stefan Koopmanschap taking a look at the latest major release of the Symfony PHP framework (v1.1) and some of the functionality it includes.

The official stable release of symfony 1.1 is now nearly a month old, and response so far has been fairly positive. This is not surprising, as this new version adds a lot of flexibility to the already flexible system that symfony offered. Let's have a look at symfony 1.1, and specifically to the points that I feel are especially exciting in this new release.

He looks at the new architecture of the framework, how it now handles forms, the improvements to the plugin system and the (partial) integration of the Propel ORM layer for accessing databases. The full listing of updates can be found here.

A recent post on the Developer Tutorials blog takes a look at a fundamental part of several of the PHP (and other language) frameworks out there - the Object Relational Mapping (ORM) layer for database access.

Instead of direct database access, an ORM layer in a PHP framework can make "objects" stored in a database behave like actual objects from a programming perspective - for example, creating a new "car" stored in the database could involve a call to $car->new(). By abstracting actual database access, web development can be more productive and result in more reliable applications. Here's a quick intro to ORM in PHP.

They talk about ORM's role in how applications interface with data (abstracted out to objects) and some examples of it in current frameworks - CakePHP and Symfony.

The Oracle Technology Network has a new article posted looking at a basic application that combines the power of an Oracle database with the flexibility of the Symfony framework.

Where should someone who wants to learn Symfony begin? Project Symfony has a very informative and well-kept Web site, with extensive documentation. As it turns out, there is a book about Symfony and there are also numerous tutorials-unfortunately all of them created using a MySQL database. That is, in essence, why I decided to write this article about Symfony and Oracle. It's not a full-blown tutorial, but I hope it will be helpful to those who want to use Symfony with Oracle.

The sample application uses the latest version of Symfony, an Apache web server and the Zend Core for Oracle to install and configure the needed setup. The bulk of the tutorial is taken up with examples of how to tell the ORM layer of Symfony about your database tables and how to build the default classes from them.

Francois Zeninotto has posted a comparison of three different ORM (Object Relational Mapping) layers for PHP - Propel, Doctrine and sfPropelFinder (the last being a plugin of the symfony framework).

When it comes to ORMs, it's all a matter of preference. Is it, really? This post compares side-by-side the code required to perform some simple operations with three OO database requesting API. The purpose is to demonstrate that productivity, and not only style, can vary a lot depending on the ORM you choose.

He's worked up a long list of examples including methods to:

• Retrieving an article by its primary key
• Retrieving the latest 5 articles
• Retrieving articles based on a complex AND/OR clause
• Retrieving articles authored by people of a certain group
• Retrieving an article and its category by the article primary key
• Retrieving articles and hydrating their author object and the author group

Each one comes with their own (usually simple) code. His conclusions point out different "bests" of each - like sfPropelFinder being the "most magic" and that some of the limits of Propel are very frustrating.

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.

Lukas Smith got a chance to catch up with Rasmus Lerdorf (and others in #php.pecl) and "talk shop" about topics including handling large libraries and maxclients settings.

In this first post I will provide a link and some commentary on Rasmus's points regarding Doctrine (note I left independent chatter in the log in order to not have any chance of me filtering the content, but there is very little of that so I hope the discussion is still easy enough to follow).

Nik Chankov feels pretty strongly about the CakePHP framework - strong enough that he's written up a post of ten reasons why he thinks you should choose Cake over other PHP frameworks.

Here I want to list all those things, but near to each of them I will give short explanation what is it and how CakePHP implement it. So, if somebody ask me what are those 10 things which drive me to choose this framework as my primary one I will answer with [this list].

Included in his list are things like it's MVC pattern, the object relational mapping, that it's easily extensible, has ajax support and makes the CRUD scaffolding easy.