Symfony Live 2015 — The First Day
The conference part of Symfony Live 2015 took place in Berlin on the 15th and 16th of October. We had the chance not only to attend with our whole PHP department, but also to contribute to this event and the hackathon, which happened on the 17th of October, as a sponsor.
The organizer found a really nice location at the Golden Tulip Hotel, with two big rooms that allowed everyone to be able to find a seat, even for the keynotes. On top of that, they took great care of us by providing delicious food and drinks.
But we were not only there to enjoy the food; no, most all of us were certainly there to see what topics are causing a buzz in the PHP community and what we had missed so far. Therefore a lot of talks were planned: except for during the two keynotes, there were always two talks going on in parallel. I would like to summarize the central point for each talk I attended from my perspective in the following paragraphs.
Keynote: The Path to Symfony 3
The first day of the main conference started with the keynote presentation about “The Path to Symfony 3”, given by Fabien Potencier himself. He provided some insight into Symfony’s release cycles and especially into the problems relating to deprecations that occurred over the last few years and how Symfony ended up getting rid of deprecated components.
First of all, they tried using the trigger_error function, but this led to problems, especially regarding unit tests, since they generated a lot of output. With this approach they were able to see where the deprecated components were used inside of Symfony 2 and refactor these occurrences step by step. However, this solution has a big maintenance overhead and will not find usage for example for deprecated interfaces. In the end, Sensio Labs, the company which created Symfony, introduced a new tool called deprecation scanner, which generates a rule set and executes this as a static code analysis to find places in the code which are still using deprecated components to help solve this problem. Sadly I didn’t find any way to access this tool yet, but I’m looking forward to playing around with it once it is available.
Outsource Your CMS: Drupal 8 as a Drop-in Content Engine
Afterwards, I had to choose between two subjects and for me Drupal 8 was the most promising talk. I’ve worked with Drupal 7 in several projects and it was always a mess, which ended up with me crying in the corner. So my expectation was really low at this point. For those who don’t know, Drupal is a content management framework that focuses on flexibility without requiring coding knowledge. In its current version, Drupal is not only built with a lot of Symfony components and with improvements to its overall code, but new features have also been introduced. When I say the code has been improved, this is an understatement. To me Drupal 7 and Drupal 8 look totally different from each other: where Drupal 7’s code was a hell of global functions, Drupal 8 now seems a lot more structured. One of the most promising features was the “View” feature, which basically is a projection of a data source into different output formats. With this feature it is not only possible to represent a data source as different HTML pages, like lists, tables, etc., it is also possible to build a REST view which will create REST endpoints to access these data. Besides the interesting content, the talk itself was also extremely entertaining.
Decomposing Packages
The next talk was about advanced composer package management. Luckily the slides are available here, so you can take a look at the content for yourself. The main points for me were the possibility of replacing packages and annotating that a big package can provide certain smaller packages to avoid having to download the code twice. At least I wasn’t previously aware of these features, but the rest was not new to me and I expected something different for this talk.
Microservices: Small but Powerful!
After a delicious lunch, Stephan Hochdörfer from Bitexpert gave an overview about Microservices, including a lot of good practices and tools which can help a company interested in trying out this approach. For me, beside the tools, there was nothing new, but everyone who is interested should at least take a quick look at the slides.
Growing Your File System
Already some months ago, I stumbled upon https://thephpleague.com/, a group of people who are developing outstanding PHP libraries. One of these libraries is flysystem which aims to create a unified interface for different file handling possibilities. This talk was held by the creator of flysystem, Frank de Jonge, who gave a quick introduction on the difference between file systems like our local ones and S3, FTP, Dropbox, etc. and how they all behave different and the lack of a shared interface for working with them. This problem is tackled by flysystem, which was introduced in the talk along with some common best practices, like splitting up your file system into use-case-specific buckets which allow you to scale each bucket in the future according to your requirements. There was one sentence I remember from the talk which everyone should keep in mind — loosely translated: you should defer decisions as long as possible, because the future you will hopefully be smarter or at least understand the requirements better.
The Quest for Global Design Principles
The last talk was the one I had looked forward to the whole day. Mathias Noback, known for his book “One Year with Symfony”, gave another perspective on applications which can be converted to cross application communication. The different layers of an application can also be seen as different inter-actors that will communicate via messages. So each method argument will be viewed as a message and therefore has to have all necessary information inside and should explain itself to the outside. This will not only result in reduced knowledge duplication; it will also create the benefit that this message can also be sent via a message queue if there is a need to scale components differently. He also proposed taking a look at internal APIs like the PHP password-hash function and at least trying to have meaningful parameters. So instead of using just a key-value-based array to pass options a specific class should exist for the options that will document all the possible options and also have the ability to ensure that required parameters are set. This will help in understanding internal APIs without the need to look into separate documentation. All slides are published online and in my opinion taking a look at them is definitely not a waste of time.
Lightning Talks
After this already long day full of a lot of awesome talks, the organizers gave all the people who were willing to do a short talk the chance to speak about whatever they wanted to in 10 minute slots.
The first so-called lightning talk was given by a member of Thelia and was about a new project they started to create a customer-based product recommendation using machine learning algorithms and statistical methods. Sadly there was no further information on where to find this project.
Next, a guy from Lovoo gave us insight into their spare time project, which they created in a space similar to what we call Open Space at Project A. They created in such a time slot on the one hand a testing lab to test their mobile app on different real devices and on the other hand they created a robot with a camera and a rocket launcher, which can be remotely navigated using a playstation controller to give external people the possibility to explore their office.
The third lightning talk from Auxmoney was about a javascript library called resi.js, a tool to handle responsive images on different devices and improve their SEO ranking.
The last talk I remember was from platform.sh about the “good old days”, where development, staging and production were exactly the same and no differences between them were there to make a developer’s life hard. Basically that idea is covered by platform.sh, which is a cloud provider, which gives the ability to create exact duplicates of an existing infrastructure to test against without any difference.
The Day in Conclusion
There were a lot of interesting talks, but nothing totally exciting for me, even though the conference was one of the best conferences I’ve ever been to. So I was really looking forward to the next conference day, which seemed to me a lot more interesting.
In my next blog post, you can read whether my hopes were fulfilled on the second day of the Symfony conference, so stay tuned! ;)
