Posted by Robert Janeczek on 10/09/29 11:13

On Wed, 13 Apr 2005, Richard Lynch wrote:

> On Wed, April 13, 2005 2:01 pm, Robert Janeczek said:
>
> I can't claim a detailed understanding of what you are doing, and,
> frankly, it sounds like you are creating a BUNCH of over-engineered
> headache-inducing code without a good, proven need for it. YMVV.

The Upper Case Nice Names I used before are not really difficult to
implement. Some of these patterns are even smaller than most
implementations of GOF design patterns.

> That said, one thing I *did* understand and can comment on:
>
>> Sample code:
>> $company = CompanyMapper::find(1); // we have ghost inside $company
>> //some other operations, but we don`t touch $company
>> $company2 = CompanyMapper::findByName('Big Ltd.');
>>
>> Now let`s assume, that company with ID=1 has name Big Ltd. We have two
>> independent copies of the same object what kinda sucks :] The problem is
>> that both finding methods return ghosts and the second one doesn`t know
>> his ID yet. If there would be only ID-based searching than Identity Map
>> would detect it and caused returning the same instance, but it`s not...
>
> So why not do this:
> Make findByName look up the $ID with the query you already use, possibly
> caching the other fields/data you use frequently in some kind of very temp
> space: $row (array returned from query).
> Then call CompanyMapper::find($ID, $row);
> which uses the info it already has given for free in $row, but can also
> check your cache of existing object, fill in any free data from $row, and
> return the existing object if it's there.

The problem is that both finding methods don`t query the database when
they are called. They just store information how can the database be
queried to fetch the data which should be inside them. So - I don`t have
ID inside $company2 unless I accessed it`s variables.

> Perhaps a specialized object that manipulates/returns other objects based
> on arguments is in order. Instead of a zillion objects that all do that
> same thing, only one for each real object, you have one that handles all
> the other objects the same way, but trying to find the same object in your
> cache first, then digging deeper into lazy load (or whatever) to build it.

That`s what Identity Map doing - it keeps track of all business objects
inside application. Still - after doing find*() there is no way to tell
that two variables are the same object inside until they are accessed. And
after they are accessed it`s already to late, because we have two
instances.

> How certain are you that all this code is saving you *ANYTHING*?

Quite much :) Honestly - it`s a pleasure to write code for application
using this architecture. Repetition of code is basicly non-existent,
except for interfaces (which are generated automaticly anyway).

> Is it worth the development/maintenance expense?

The expenses are not really high. The biggest problem is that if come to
dead
end somewhere than we have to look for solutions in java literature :] And
of course it takes time for PHP developer to switch to using it, but
that`s not different from any framework.

It`s worth the effort, trust me :)

rash

[Back to original message]