Matthew Weier O'Phinney

Project Lead

Ralph Schindler
Software Engineer
Introducing
Zend Framework 2.0
3 November 2010
 Some History

Summer 2005:
Coding begins on Zend Framework, with a 
handful of cherry­picked partners.

2
 Some History

Fall 2005:
First annual ZendCon
Andi and Zeev announce the PHP Community 
Process, which includes involvement in the 
Eclipse Foundation, a relaunch of Zend's 
Developer Zone, and Zend Framework.

3
 Some History

March 2006:
Zend Framework 0.1.0 released
Project opened up to the public for 
contributions; contributions require a 
Contributor License Agreement.

4
 Some History

July 2007:
Zend Framework 1.0.0 released
Project includes MVC stack, Table and Row 
Data Gateways, loads of Service APIs, 
Authentication and Authorization layers, service 
providers, and more.
Still largely deemed a work in progress. 

5
 Some History

March 2008:
Zend Framework 1.5.0 released
Includes Zend_Form and Zend_Layout, and 
many Zend_View enhancements. 

6
 Some History

September 2008:
Zend Framework 1.6.0 released
Includes Dojo Toolkit integration, functional test 
utilities.

7
 Some History

November 2008:
Zend Framework 1.7.0 released
Includes AMF support, performance 
improvements.

8
 Some History

April 2009:
Zend Framework 1.8.0 released
Includes Zend_Application, Zend_Tool.
First release widely seen as providing a full 
stack.

9
 Some History

July 2009:
Zend Framework 1.9.0 released
Includes reworked feed component, 
Zend_Feed_Reader, and tons of community­
driven enhancements.

10
 Some History

October 2009:
First monthly community bug hunts launched.

11
 Some History

January 2010:
Zend Framework 1.10.0 released
Includes Zend_Feed_Writer, re­organized 
documentation, and community­driven 
improvements.

12
 Some History

February 2010:
Development on Zend Framework 2.0 begins

13
 Some History

June 2010:
Formation of the Community Review Team

14
 Some History

November 2010:
Zend Framework 1.11.0 released
Includes mobile support and 
SimpleCloud API.

15
 Some History

The future?

16
Revolution?
Evolution.
 Incremental Improvements

Autoload only (strip require_once calls)
Conversion to PHP namespaces 
Refactor and standardize exceptions usage
Refactor and consistently implement a 
single plugin loading strategy
Refactor to use PHP 5.3­specific paradigms 
where they fit

19
Rewrite only 
where it makes 
sense
 Zend_Db

Difficult to get the underlying connection 
and share it between instances or different 
classes.
Difficult to get schema metadata in a
consistent fashion.
Difficult to extend.
Difficult to add pre/post tasks.

21
 Zend_Session

Black­box design != testable
Namespace storage incompatible with 
$_SESSION 
Many incompatibilities with ext/session

22
use Zend\Session\SessionManager,
Zend\Session\Container as SessionContainer;

$manager = new SessionManager(array(

'class' => 'My\Custom\SessionConfiguration',
'storage' => 'My\Custom\SessionStorage',
));
$container = new SessionContainer('Foo', $manager);
$container['somekey'] = 'somevalue';
$container->setExpirationHops(2);

23
 Filters and Validators

Static access and chain usage were mixed 
in the same object
Did not use common plugin loading 
methodology
Paradigms required in Filter_Input and 
Form were not supported

24
namespace Zend\Validator;

if (StaticValidator::execute($value, 'int')) {
// passed validation
}

$chain = new ValidatorChain();

$chain->addValidator(new I nt(), true)
->addValidator(new GreaterThan(10));

if ($chain->isValid($value)) {
// passed validation
}

25
 Add
features favoring 
extensibility
 Examples

SignalSlot
FilterChain
SPL extensions (SplStack, SplQueue)
PluginBroker

27
Favor the Explicit
Okay, not that kind of explicit…
 Magic is 
sometimes
too arcane
echo $this->headLink()->appendStylesheet('foo.css');
/**
* Hits Zend_View::__call()
* Calls Zend_View::getHelper()
* Calls Zend_View::_getPlugin()
* Calls Zend_Loader_PluginLoader::load()
* Calls Zend_Loader::isReadable()
* Calls call_user_func (hits autoloader...)
* which calls Zend_Loader::loadClass
* which calls Zend_Loader::loadFile
* which calls include_once
* Instantiates helper
* Calls method on helper via call_user_func_array()
* Returns helper instance
* Call method on instance (hits __call...))
*/
30
(hidden) automation 
makes learning hard
class FooController
extends Zend_Controller_Action
{
public function someAction()
{
$this->view->foo = 'bar';
}
}

Where is 
this defined? When is 
What about
it rendered?
layouts?

32
 Explicit code is…
easier to 
understand

$this->broker('head_link')
->appendStylesheet('foo.css');
/**
* Hits PhpRenderer::broker()
* Calls HelperBroker::load()
* Calls HelperLoader::load()
* Hits autoloader
* which simply does an include_once
* Instantiates helper
* Calls method on helper
*/
Explicit code is…
easier to
profile
Explicit code is…
easier to
maintain
 Optimize for 
performance
37
 Profiling

Profile to determine 
where the pain 
points are
Look for big gains 
primarily
Fix them

38
 Autoloading: Problems

Class Maps are fastest
But they require maintenance
Using the include_path is slow
Not using it requires maintenance
Using the include_path is most flexible
But slower than alternatives

39
 Autoloading: Solutions

Ship a ClassMapAutoloader by default
Class maps for full ZF library, and per­component
Tools for generating class maps
Ultimate in performance

StandardAutoloader requires 
namespace/path pairs
Flexibility and performance during development

StandardAutoloader can act as a fallback 
autoloader
Flexibility at the cost of performance 40
// .classmap.php
return array(
'Foo\SomeController' => __DIR__ .
'/foo/controllers/SomeController.php',
'Foo\Model\Bar' => __DIR__ . '/foo/models/Bar.php',
);

// ClassMapAutoloader
require_once 'Zend/Loader/ClassMapAutoloader.php';
$loader = new Zend\Loader\ClassMapAutoloader(
'./.classmap.php');
$loader->register();

$bar = new Foo\Model\Bar();

41
// StandardAutoloader
require_once 'Zend/Loader/StandardAutoloader.php';
$loader = new Zend\Loader\StandardAutoloader(array(
'namespaces' => array(
'Foo' => __DIR__ . '/library/Foo'),
));
$loader->register();

$bar = new Foo\Model\Bar();

42
 Plugin Loading: Problems

Path stack­based autoloading is sloooow
Prefix paths are hard to grasp
Particularly when coupled with stacks
Overriding the paths without propagating 
paths is hard
Case sensitivity becomes an issue

43
 Plugin Loading: Problems

Current solution only solves the class 
loading aspect of plugin loading
Instantiation happens differently per 
component
Persistence happens differently per 
component

44
 Plugin Loading: Solutions

Class alias based maps by default
Loaders are coupled with brokers
Handle instantiation, including arguments
Act as registry
Allows attaching single broker to many 
objects

45
/* class loader */
namespace My\Component;
use Zend\Loader\PluginClassLoader,
Zend\Loader\PluginBroker;

class ComponentLoader extends PluginClassLoader

{
protected $plugins = array(
'foo' => 'My\Component\Foo',
'foo_bar' => 'My\Component\FooBar',
);
}

46
/* class broker */
namespace My\Component;
use Zend\Loader\PluginClassLoader,
Zend\Loader\PluginBroker;

class ComponentBroker extends PluginBroker

{
protected $defaultClassLoader =
'My\Component\PluginClassLoader';

protected function validatePlugin($plugin)

{
if (!$plugin instanceof Adapter) {
throw new Exception\RuntimeException();
}
return true;
} 47
}
/* factory */
namespace My\Component;

class Factory
{
/* Not shown: setBroker() and broker() methods */

public function get($adapter, array $options)

{
return $this->broker()
->load($adapter, $options);
}
}

48
Ease the learning curve
Common Documentation Complaints

Options are (often) not documented.
Available functionality (typically, methods) is 
not presented.
Inconsistent structure between 
documentation of different components.
Examples do not show common use cases, 
only using the component individually.
No examples showing complete application 
development. 50
 Common Learning Problems

Magic (“__” methods) is hard to learn 
(just ask Harry Potter).
Uncertainty where and when to extend or 
implement extension points – and how to 
get ZF to use them.
Some patterns are non­obvious in usage 
(Zend_Form decorators…).

51
 Proposed Solutions

Coding:
Refactor where usage patterns differ 
from design
Reduce number of magic calls
Refactor for consistency
Refactor unclear APIs

52
 Proposed Solutions

Documentation Standards:
Introduction
Quick Start
Options
Methods
Examples

53
The Roadmap
 Completed Milestones

Migration to Git for ZF2 development
Stripping of require_once calls
Migration to PHP 5.3 namespaces
Including SPL additions, Session rewrite, and 
addition of SignalSlot
Autoloading and plugin loading/brokering
Including View rewrite
Exceptions
In fact, we've just released a new  55
 Completed Milestones

Zend Framework 2.0.0dev2:
http://bit.ly/zf2dev2

56
 Remaining Milestones

MVC Refactoring/Rewrite
Internationalization and Localization
Testing
Documentation
Packaging
Migration tools

57
How 
YOU 
can 
help
 Contribute to ZF2!

ZF2 wiki:
http://bit.ly/zf2wiki
zf­contributors mailing list:
zf­contributors­subscribe@lists.zend.com
IRC: 
#zftalk.dev on Freenode

59
 ZF2 Git

Git guide: 
http://bit.ly/zf2gitguide
GitHub: 
http://github.com/zendframework/zf2
Official repo: 
git://git.zendframework.com/zf.git
http://git.zendframework.com/
You still need to sign a CLA!
60
http://framework.zend.com

Thank you!
Feedback: http:://joind.in/2287
Twitter: weierophinney, 
ralphschindler