In order to get a bit of "hard data" on what accessors will actually be used for once they are introduced I wrote a small script that scans through a codebase, finds all getter and setter methods and checks them for various characteristics. (The analyze.php file in this Gist.)
Here are the results of running it on a Symfony (Standard) skeleton.
absoluteTotal => 18516 (486.6%)
total => 3805 (100.0%)
skipped => 124 ( 3.3%)
get => 2767 ( 72.7%, 100.0% of get)
getInterface => 274 ( 7.2%, 9.9% of get)
trivialGet => 928 ( 24.4%, 33.5% of get)
simpleGet => 1172 ( 30.8%, 42.4% of get)
getWithCheck => 107 ( 2.8%, 3.9% of get)
set => 914 ( 24.0%, 100.0% of set)
setInterface => 92 ( 2.4%, 10.1% of set)
trivialSet => 354 ( 9.3%, 38.7% of set)
trivialSetChaining => 77 ( 2.0%, 8.4% of set)
simpleSet => 49 ( 1.3%, 5.4% of set)
simpleSetChaining => 16 ( 0.4%, 1.8% of set)
setWithTypeHint => 289 ( 7.6%, 31.6% of set)
unclassified => 612 ( 16.1%)
The same for Zend Framework:
absoluteTotal => 9876 (242.1%)
total => 4080 (100.0%)
skipped => 45 ( 1.1%)
get => 2480 ( 60.8%, 100.0% of get)
getInterface => 264 ( 6.5%, 10.6% of get)
trivialGet => 1070 ( 26.2%, 43.1% of get)
simpleGet => 465 ( 11.4%, 18.8% of get)
getWithCheck => 266 ( 6.5%, 10.7% of get)
set => 1555 ( 38.1%, 100.0% of set)
setInterface => 138 ( 3.4%, 8.9% of set)
trivialSet => 120 ( 2.9%, 7.7% of set)
trivialSetChaining => 397 ( 9.7%, 25.5% of set)
simpleSet => 14 ( 0.3%, 0.9% of set)
simpleSetChaining => 189 ( 4.6%, 12.2% of set)
setWithTypeHint => 342 ( 8.4%, 22.0% of set)
unclassified => 1112 ( 27.3%)
An overview on what these stats mean and how I interpret them:
absoluteTotal, total:
"absoluteTotal" is the total number of methods, "total" is the number of accessors,
i.e. no-param methods starting with "get" or single-param methods starting with "set".
As you can see getseter make up a large part of the methods. For Symfony 20% for
ZF even 40%.
=> Getter and setter are a *very* common pattern, so it makes sense to do work in
this direction.
get, set:
"get" is the number of getters, "set" the number of setters. You can see that people
use a good bit more getters than setters. For Symfony there are about 3x more getters,
for ZF it's 1.6x as many.
=> It is common to have read-only data. This may either mean that there will be many
accessors with asymmetric visibility or that many properties will only define a get
accessor.
getInterface, setInterface:
Number of getters/setters defined in interfaces or as abstract methods. This is about
10% for both projects.
=> Accessor and property support in interfaces is necessary.
trivialGet, trivialSet, trivialSetChaining:
"Trivial" means that the accessors act as a direct proxy to another property. The trivial
set chaining variant also proxies to another property and additionally returns $this.
For Symfony about 35% of all accessors are trivial. ZF also has 40% trivial getters, but
seems to be rather fond of chaining, so 25% of the setters are trivially chaining.
=> A good chunk of all getters/setters don't really do anything. Once we get accessors they
can be basically replaced by public properties. Accessors give the possibility to add more
behavior lateron.
simpleGet, simpleSet, simpleSetChaining:
A simple getter contains only a return statement, a simple setter only one assignment. For
Symfony 40% of the getters are simple (this is not counting the trivial ones), for ZF it's
20%.
=> Many getter are very simple and I think that especially the simple ones will be the ones
converted to property accessors.
This category is rather vague. Here are the three main types of simple getters I've found:
1. Getters returning a constant value. This is more common than I would have thought. Good
example of such a case are getName() methods that commonly return a constant string. Others
return arrays or constants.
=> There seems to be need for read-only, constant properties.
2. Proxies to other getters ($this->foo->getBar()).
3. Getters taking some property and doing some small postprocessing, like replacing a string
or similar.
getWithCheck:
Getters which contain an if condition (containing a single statement), followed by a return.
This is a common pattern for lazy loading. Amounts to 10% in ZF and 4% in Symfony.
setWithTypeHint:
Setters where the argument is type hinted. 30% of the Symfony setters have one and 20% of
the ZF ones.
=> There should be a simple way to typehint properties.
@nikic: Thanks for sharing! Could you add version numbers to the report?
In the code I see ZF 2.0.2, but what version of Symfony was tested? 2.0|1|2 ?