Symfony 2 Online Conference Report

So, on Tuesday we organized the Moscow hub and conducted a live broadcast of the conference. For the organizers, as I understand it, this was the first experience in conducting events of this kind. And everything went great. We connected to the session, the speaker spoke in the background and flipped through the slides. There was no video. It was a little difficult to perceive information by ear, but on the whole it was understandable, the guys tried.

Reports

"Miscellaneous enhancements" by Fabien Potencier
http://www.slideshare.net/fabpot/news-of-the-symfony2-world

The reports slightly moved and first started Fabiens with an introduction to various innovations.

• Introduced a fundamentally new DOM parser that supports all css3 selectors.

    Parser :: cssToXpath ('h4> a: contains ("foo")'); 

  This parser is the basis for another component - DomCrawler.
  ')
  
• DomCrawler
  See the presentation how it looks and works.
  First of all, this crawler is used in functional tests, to work with the “answer”: select the elements according to the condition, find and fill in the form, etc.
  We get full and convenient access to the tree, the nodes and their attributes.
  Fabien presented an example of a simple browser based on such a crawler.
  
  
• Finder
  Advanced iterator for working with files: select a list of files by mask, filter, sort. Returns files as objects with attributes.
  See details
  • http://habrahabr.ru/blogs/symfony/91689/
  • http://fabien.potencier.org/article/43/find-your-files
  • http://fabien.potencier.org/article/44/php-iterators-and-streams-are-awesome
• Kernel
  Kernel framework. Simple interface - 2 methods to accept the request and respond.
  Such simplicity allows you to write your own “cores”, where you can stitch up any logic that wraps up the “request” and “answer”. You can write your own solutions for testing, profiling, caching, etc.

In the end, Fabien warned everyone that the framework is under active development and that it does not guarantee the stability of the API. "We will add new code, delete the existing one, actively refactor, but most importantly, the symphony's philosophy will remain unchanged."
What is now up and running is a preview release. The first alpha is scheduled to be posted in September.


"Symfony 2 Meets Propel 1.5" by François Zaninotto
http://www.slideshare.net/francoisz/symfony2-meets-propel-15-4

Francois introduced a new version, telling how good and better it was than previous versions. But there was some kind of uncertainty in the bright future of this ORM.
We were introduced to new "killer features":

• Model query
  Abandoned "criteria" and now requests are written in a similar way as in the doctrine, only in a different paradigm.
  Joyns look original. And if we take into account that instead of peers / tables we work with query, then you can pretty well spread the logic (write your own filters) on the corresponding query and get rid of duplication in queries.
  
  
• Concrete table inheritance
  Implemented model inheritance from one table. Something similar is the doctrine .
  However, I didn’t like the solution when, when the object is saved, the data is written to a specific table and duplicated in the parent. I did not understand why.
  In other, duplication can be disabled. see doc .
  In the doctrine I like Column Aggregation Inheritance more . When all records are in the same table, where there is a column with object types. When we select a list of objects, we get a collection of different types. And for every type we can hang our business logic.
  
  
• Aggregate Column Behavior
  Automatic update of the column that contains the result of the execution of the aggregation function, when the dependent table changes. Those. automatically counts / caches the number of comments from the post, the amounts, the maximum and minimum values. See doc .
  Frankly, I do not really like this approach in terms of reliability. However, everything as always depends on the conditions of the problem.

And in general:

• "The Power of Propel Generator"
• "Propel not dead"
• "Propel vs Doctrine"

And in the end, Francois vaguely spoke about the future of singing in Symfony2, and translated everything to Fabien.


"What's new in the Doctrine 2 Symfony Integration" Jonathan Wage
http://www.slideshare.net/jwage/symfony2-and-doctrine2-integration

What we have:

• Doctrine 2 is not Active Record. Congratulations to all the followers of the domain model. Now we can write our own business logic objects. We don't inherit from anyone, our own constructor, no magic. And work with the database entrust EntityManager.
  Our objects can contain data not only in the form of simple types, but also in the form of other objects. Those. we can write complex data types, such as currencies, date intervals, etc., and natively hydrogenate them from the database.
  We can write a personal EntityManager with our own rules for working with databases and hydrating objects.
  In general, a lot more room compared to Active Record.
  
  
• Migrations
  All rewritten and made this component independent. Now you can use migrations for any of your projects.
  From what I did not see in 1.x:
  - view the current status - what is the version now, etc.
  - show sql migration
  - write sql migration to file
  
  
• MongoDB
  The developers added support for MongoDB and brought it to a separate subproject. It will be interesting to try.

But, on the whole, the report turned out to be somehow chaotic and chaotic. At times people turned off.


"Unit & Functional Tests" Fabien Potencier
http://www.slideshare.net/fabpot/unit-and-functional-testing-with-symfony2

• With the release of symfony2, I think testing symfony projects will take a new step. It will become more convenient and transparent. Down with the context and memliki!
  In functional tests, we test only "output". Forms, validation and all that we can, we test in unit tests. And the speed of the tests, I hope, will be reduced.
  Fabien showed an example of functional testing in conjunction:

    Client (browser) - Crawler (DOM) - Assert (phpunit) 

  see presentation.
  
  
• Requests to the application can be run in separate processes. Those. in one test to make 2 conditionally simultaneous requests. But I did not quite understand why. These are still functional tests, not stress tests.
  
  
• Now this component is independent of the symphony application and can be used to test ANY web applications. Because he can both simulate a request to a symphony application, and honestly go over http.
  Therefore, if you do not have a symphony application or have legacy code, you can cover it with these tests, and in the case of transferring to a symphony, these tests will not have to be rewritten.
  
  
• I also liked the opportunity in tests to get access to the profiler / statistics in order to test, for example, the number of queries to the database, the execution time of the controller, etc.

"The new form framework" by Bernhard Schussek
http://www.slideshare.net/bschussek/the-new-form-framework

Again, all rewritten.
Now forms is only a visual presentation. All validation is cleverly placed in the model, see the presentation.
The main question that I had was: "What about the custom forms?".
That's how:

• Validation rules can be grouped and given to form a specific group (with part of the fields, with separate rules)
• for a custom form, we write a personal class-model, where we indicate the appropriate validation rules

In general, it is curious, it is necessary to try and see what happens.
But, at a minimum, testing will be much easier.


"The Symfony 2 Killer Feature ..." Fabien Potencier
http://www.slideshare.net/fabpot/caching-on-the-edge-with-symfony2

As you might have guessed, this is caching.
Symfony2 is a completely new look at caching, and benchmarks show generally the utmost difference. And the essence is in RFC 2616 (13. Caching in HTTP).
First, in the controller, we specify the cache lifetime and the response generates the corresponding http headers. At first glance, this is nothing revolutionary if it were not for the built-in HTTP proxy. Which wraps the application kernel and manages caching and does not allow requests to the application if it has a cache.
For partials, which should be cached at different times, technology similar to SSI is used, where the corresponding partial is connected and processed separately in accordance with its own settings.
And if you put reverse proxy on top of it, such as nginx, then due to the caching headers, requests won't reach the application at all.

It is recommended to manage the cache after “puffing” time. But you can also disable specific URLs.


Everything.
The organizers, as promised, have posted a new document describing the individual components.
As a result: Symfony2 is a fundamentally new framework, not only in comparison with 1.x, but in general in comparison with other php frameworks. There is still a lot of work ahead, but most importantly, Symfony2 is already a reality. Join now!

Propariu Russian newsletter . Not to say that it is quite active, but I think that this is a good gathering point. There, I will announce all my initiatives, such as, for example, meetings at Symfony code'n'coffe.