Symfony Catalunya - Conference report
Last week I took part in the first ever Symfony Catalunya conference. The conference was a major event in Barcelona, attracting 400+ Symfony developers. It seems that most of the attendees were from Spain or Catalunya. I was surprised to see that some Dutch people were present too!
Earlier this year one of the organisers, Marc Morera, opened the Call for Proposals for this conference, asking speakers to submit talks that they hadn't delivered before. As Marc puts it: "I want the speakers to suffer." Not literally of course, but he wanted to prevent the conference from becoming Just-Another-Conference with the same talks that you had already seen at other conferences (though I always wonder if that is really a problem, because: how many people actually visit that many conferences across Europe?). Still, I liked the idea and, as described in a previous blog post I submitted a talk which was definitely going to give me a hard time - a "soft" talk, about the things we developers can learn from a famous astronaut like Chris Hadfield.
In the end, I had a great time delivering it. A video recording of it is bound to appear soon.
Michael Cullum - Breaking Boundaries with the PHP-FIG
The conference schedule had a lot of gaps in it, which allowed people to get out, eat and drink whenever they liked, catch some sun or run to get out of the pouring rain.
I didn't see many talks, but I did watch Michael Cullum's new talk about the PHP-FIG, of which he is currently a secretary. The talk started with a short history of PHP, starting in 1994 and ending with an overview of efforts by "the FIG" to build bridges between the islands that have otherwise been living quite separated from each other, like the Laravel island, the WordPress island, etc. This is an effort I appreciate very much.
Looking back at some of the more recent PHP history, we should consider ourselves very lucky with PSR-0 and Composer, which allowed us to easily install different components from different "ecosystems" without getting in each other's ways. The same goes for PSR-1 and PSR-2, which have made it quite easy to dive into another code base and not be distracted by code layout.
Some useful and surprising insights from this talk:
PSRs are no laws
Nobody is forced to adopt a PSR. Also, if there is a PSR about a certain technical thing, nothing prevents us from creating an alternative PSR. Currently this is happening to PSR-6, "the cache PSR", for which there is another draft PSR that proposes a simpler version of a cache API.
If a PSR doesn't fully match your style or needs, it's also possible to extend a PSR and elaborate on it a bit more.
97% of communication on the FIG mailing list is about technical things
On our Twitter timelines we are on a regular basis confronted with all the drama related to the FIG. This could lead many of us to think that the FIG is lost; that it spends almost all its time discussing who's allowed to be a voting member, who should be expelled, etc. Although obviously something has to change, the FIG is still (and luckily so) mainly about technology and defining standards that support amongst other things framework interoperability. The proof for that: about 97% of what's being written on the FIG's mailing list is about technology.
To improve the image of the FIG as perceived by the larger PHP community, the FIG is working on something to update the community about what's going on with for example the PSRs that are being drafted or voted on.
Jeremy Mikola - Five Years of Beta
The final talk of the conference was an interesting one by Jeremy Mikola. Jeremy has two faces really. Many of us know him as a comedian, doing lightning talks and being Jeopardy show master. The other side is that of a hard working (open source) developer, taking his work very seriously.
He's been maintaining the Doctrine MongoDB ODM project for quite some time. His talk described the process of getting the project out of its beta-phase (which lasted for 5 years). Getting it ready for the stable 1.0.0 was hard in many ways. I could relate to many of the problems he encountered:
- It's scary to settle on a public API, knowing that users will start depending on it. From the moment you release a stable version, you'll have to take care of not introducing backwards-compatibility breaking changes.
- After some time the code of an open source project like the ODM starts breaking spontaneously because of changes in one of the dependencies. For example, each new version of Symfony comes with a set of upgrade steps to follow. Then sometimes you need to protect backwards compatibility as well or maintain code for different (major) versions of dependencies, for example in the case of changes in the MongoDB server itself, or in one of its drivers.
- Even while the project was still in beta, several projects started depending on them and even though the project wasn't tagged "stable", as a maintainer you still want to support those projects. One of the projects to think about in the case of the ODM is for instance the Gedmo extensions library.
- The Doctrine ORM team had been working on improving the ORM and releasing new versions of it. This put some pressure on the ODM project as well, to keep up with the changes in the ORM, improve the project, add new features, etc.
Several things to remember about open source maintenance and start putting into practice too:
- Triage the issues and PRs. Easy to answer, easy to fix? Or impossible to fix without introducing BC-breaking changes? Add appropriate tags for everything. This will make it easier to browse the list of open issues and not feel overwhelmed all the time. I was reminded of the Getting-Things-Done principle to "not have the same thought twice" - this is particularly true for issues/PRs: you don't want to go over the process of deciding what to do with them twice.
- Release on a time-based schedule. Plan your milestones, put issues/PRs into milestones and make sure you release on time, instead of constantly adding stuff to the list of things to release at once. This works well for the Symfony project, as well as the PHP core project itself.
Tactical DDD workshop - Entities, value objects and aggregate design
On the second day I did a workshop on Tactical DDD. It has been recorded too and should be available soon. The code for the workshop can be found on GitHub.
We covered some of the basics of object-oriented programming, which provided the necessary vision to start designing entities, value objects and combine them into meaningful and useful aggregates. We ended with an example of how domain events and dispatching them can be used to apply eventual consistency instead of immediate (transactional) consistency.
Interesting talks, a very friendly audience and a great city made Symfony Catalunya a wonderful conference to attend. They intend to keep prices low (€ 50,-) and since this conference takes place in the summer holiday, maybe you can combine it next year with a longer stay in Barcelona...