For me this was one of the most expected conferences in 2015. If you just look at the impressive speakers lineup you’ll see that I am right. The aim of this conference was to familiarize the attendees with some of the modern coding design principles.

The event was organized by people from PHP Serbia user group. These people really deserve all the credit for making everything go so smoothly. Similar to the last conference I didn’t participate in organizing but I am certain that it took my colleagues a great effort to organize an event of these proportions.

The Conference

On Saturday morning an impressive number of people came to attend and the hall was filled to the last seat. This indicates that many people really want to improve their programming skills.

Shawn McCool was the first speaker. His talk was named “Designing a model architecture”, I am sure that it is a topic that everyone wanted to hear about. The talk started with a review of the traditional multi layered architecture approach and then the audience was presented with a more modern approach that consists of three layers: Domain – Service – Presentation. There was also some Active Record criticism which is of course justified. The most interesting part for me in this talk was when Shawn started asking the audience about where in those three layers do some of the concepts belong, I think it’s a good way to communicate with the crowd. Repository, Command Bus and Event Listener patterns were covered after that. A really nice talk.

The next one was Rob Allen, who is one of the most well known Zend Framework contributors. I really enjoyed this talk, as Rob was presenting in a really relaxed and casual way. Everything that needed to be said about Dependancy Injection, was said in this talk. Types of dependancy injection were mentioned, some concepts such as that the object should be valid right after constructing and that interfaces should be used for type hinting rather than concrete classes. Dependancy Injection container concept and Pimple were also mentioned. At the end there were a few words about the Service Locator pattern and how it actually introduces hidden dependencies. Rob summarized Dependancy Injection nicely at the end “it is $25 term for a $5 concept”.

After the lunch we came to a talk from Mathias Verreas labeled Identity. A day before Mathias held a  workshop that was also about DDD and it was very interesting hearing some of the concepts that he suggests. This talk was actually nice, although I think that it might be a good idea for the future to have more slides as it keeps audience’s attention, especially after lunch. The idea of Value Objects that Mathias talked about is a great topic and, as Mathias said, if you can implement only one thing from DDD, it should be value objects. Value objects are basically about wrapping some behaviour in an object, so instead of having temperature indicated by an integer for example, it would be better if you could wrap it in an object so that you can have some other information there as well, such as is it Kelvin or Celsius, maximum and minimum temperatures, etc. I am convinced that applying this would improve anyone’s application architecture immediately.

Our friends from ITSerbiaPodcast went to the stage and asked the first three speakers a few interesting questions. Unfortunately I missed that part.

Sylius is an ecommerce platform that gets more and more attention and it’s lead develeper Pawel Jedrzejewski came up next. His talk was “Sylius Under the Hood”. Sylius is actually built on Symfony framework and makes use of it’s component based approach. It looks like Sylius is very decoupled and different parts of the application can be used individually. All the depenencies are visible which makes it easier to customize. Pawel then lead us through some parts of the project, such as Taxable Interfaces, Promotions and the same principle applied everywhere – everything can be easily switched and replaced with another implementation as long as it conforms to the interface. The most interesting part to me was the checkout and how easily you can configure steps a customize your checkout flow. Definitely a project to keep an eye on.

I think that the majority of the attendees anticipated the next talk very much, as it was held by Marco Pivetta. Marco is actually one of those guys who doesn’t really have a problem expressing his opinion, even when that opinion is not popular. I am certain that this talk kept everyone’s attention because most of the points said by Marco are not something that you hear every day. He is a huge proponent of defensive programming, which basically means not letting your code to be used in an unintended way. The first shocking piece of information that we found out is that the code is not actually reusable. In fact abstractions are those that are reusable. I think it makes sense when you think about it. Some other interesting points:

• Immutability on objects is usually good, among other things it makes debugging easier
• Constructor should be the only injection point
• Avoid unnecessary public methods
• Don’t use the arguments who’s purpose is to switch control

Marco considers value objects that were mentioned earlier by Mathias Verraes as a good concept. Some more rules were there, so you should avoid mixed return types, avoid fluent interfaces and probably the one that raised the most controversy among audience: make all your classes final and avoid inheritance. I must admit that it’s a really interesting approach and idea, I will definitely read some of the stuff that is on Marco’s blog in order to get a better understanding. This was a brilliant talk.

Brandon Savage is an influential php figure and his talk was labeled The Seven Deadly Sins of Object Orientation. He basically went through all of the cases where people actually use object oriented programming in a wrong way. I could list a few of the most interesting code smells that Brandon told the audience to look out for:

• Too many dependencies
• Exposing internals
• Violating Single Responsibility Principle
• God object
• Globals
• Over abstraction

It was a nice coverage of all the stuff that you shouldn’t do in your code. One interesting point that many people forget over time was also that you should always tend to write as little code as possible. Brandon mentioned that you are not actually doing object oriented programming just by using objects and classes, you can use them and still make procedural code that is hard to maintain.

This was followed by another interview from ITSerbiaPodcast, I was present at this one and it was really nice because all of the questions were on the funny side, so it made people relax after the talks.

A great event

This was the possibly the greatest PHP event in Serbia ever. I think that everyone learned something and went home with some new ideas. Watch this space as there are more great things to come from PHP Serbia.

Would you like to recommend this article to your friends or colleagues?
Feel free to share.