Before Symfony was spelled with a capital “S” there was another symfony, the first version of the framework. It already meant a lot to me at the time. But with the arrival of Symfony 2 it became clear that something very important was happening in the world of PHP programming. It appears that this framework is able to turn amateur website makers (like I used to be) into actual software developers. What is the secret? What makes Symfony so special? And why am I still hooked? We’ll look at pieces of code, the Symfony ecosystem, the people behind it, the things that have been written about it, and the experience that I have with it. We’ll take a trip down memory lane, collecting pieces for our Symfony scrapbook, while we try to construct an answer to these questions.

1. Matthias Noback
Paris, November 19th 2015
10
years!
How Symfony
changed my life

3. Pre-symfony

4. From ASP using VBScript
and a MS Access database
To PHP with a MySQL database
"You should
try PHP!"

5. From
include('script.php')
To proper function calls

6. From PHP 4 and
one mega Page class
To PHP 5 with proper scoping for
methods and properties, and
autoloading

7. From PHP & HTML
in the same file
To PHP classes and Smarty template
files

8. From copying snippets
from the Internet
To downloading single-purpose
libraries

9. Feeling mighty fine
SQL injection
Register globals
Session
hijacking
Magic quotes
CSRF
XSS

10. Basically...

11. But... performance
was very good ;)

12. Driebit (2008)

13. symfony (1)
with a lower-case s

14. Symfony Camp
(2007)
Stefan Koopmanschap

15. The Book
(back then)
François Zaninotto
(Propel)
symfony 1.1

16. Working with
symfony 1 meant...
MVC
Fat controllers
Fat models
(Zend devs wrote fat services as well)

17. Not in the controller
or the model?
Put it in:
A "peer" class
A utility class
Or: create a global singleton for it

18. What's a singleton?
Static
Global
Single
instance
class Singleton
{
private static $instance;
private function __construct()
{
}
public static function getInstance()
{
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
}

19. God object
sfContext::getInstance()
getUser(), getResponse(),
getRequest(), getLogger(), getI18N(),
...

20. Just reach out

21. Why bad?
Testability
Isolation
Side-effects
Configuration
No separation of concerns

22. CTO at SensioLabs DE

23. Pushing the limits

24. Tweaking symfony
Event listeners: add missing
methods on the fly (!)
Filters: chain of responsibility
factories.yml and other config files

25. Switch to Doctrine
It was... new
version 1.0

26. Develop some
Plugins

27. Learn about
advanced topics
Emails
Forms
Doctrine
Internals

28. SymfonyLive
Paris 2010
Revealing
Symfony2

29. SymfonyLive
Paris 2011
Almost releasing
Symfony 2.0
Excitement all
over the place

30. Start using 2.0?
No backwards compatibility
No best practices
No CMS

31. Not even...
... an
admin
generator
only for scaffolding ;)

32. Migrating to 2.0?
Company owners didn't dare to take
the step (I agree with them now!)
I left the company :)

33. Symfony2
capital "S"
no space, for Google

34. Infrastructure
1. Git for version control
2. Install script or Git
submodules for vendor
code
3. At some point:
composer started
handling dependencies

35. Templating
Twig:
Own syntax
No PHP code
"Auto-safe"
Fast (the engine that
is)
"Templating engines in PHP" by Fabien Potencier

36. Dependency
injection container
Major improvement: everything can
be configured
No runtime resolvers anymore

37. What's dependency
injection?
class Foo
{
private $bar;
public function __construct(Bar $bar)
{
$this->bar = $bar;
}
}

38. What's a DI
container?
class Container
{
public function createFoo()
{
return new Foo($this->getBar());
}
private function createBar()
{
return new Bar();
}
}

39. What does DI give
us?
Single responsibility
Testability
Dependency inversion
Speed
Flexibility

40. Active record ->
data mapper
Doctrine 1/Propel
Doctrine 2/...

41. Active record
sample
class Invoice extends Record
{
}
$invoice = new Invoice();
$invoice->save();

42. Data mapper
sample
class Invoice
{
}
$invoice = new Invoice();
$entityManager->persist($invoice);
POPO

43. Why is that better?
Isolation
Model first
Decoupling (not always a good reason)

44. Bundle ~= Plugin

45. First-class citizens

46. A bundle for each
feature

47. Framework
coupling
Libraries are framework-
independent
Bundles are explicitly meant to
couple code to the framework

48. Bundles: service
definitions
Service definition files
Bundle extension
Bundle configuration
Compiler pass

49. Bundle: root for
resources
@MyBundle/Resources/views/
template.html.twig

50. Resources
Expose:
Templates
Translations
...

51. Assets
Assetic
Separate tools (non-PHP based)

52. Security
So very hard
Documented in many
different ways
It's really good
though
Simplified at code
level now

53. Symfony is an
early adopter
PHP-FIG
PSR-0, PSR-1, PSR-2, PSR-3, PSR-7 -
very quickly adopted

54. Extensive
documentation
High quality
Friendly
Good-
looking
Well
maintained

55. "The Book"?

56. Excellent BC
promise
@api

57. A Year With
Symfony

58. Struggling with
framework coupling

59. The fight against
CRUD

60. Hexagonal
architecture

62. phparchitecturetour.com

64. Conclusion

65. Symfony - The
biggest change
Dependency injection (container)
Which is an enabler for better
code
Because: maintainable and
testable

66. My personal
development:
1. I love symfony
2. I love Symfony2
3. I want to decouple from it
4. I want to fully embrace it whenever
that's okay

67. For me it's about
Knowing your framework
Being fast with it
Not being totally dependent on it

68. Long live
SfPot!