You’re standing on a long pier, the last ten meters of which curiously belong to international waters despite being well inside the current country’s territory. As you climb the meter-high rock wall that forms a small barrier towards the west, you’re able to witness the sun dipping into the sea, far in the distance. Soft waves caress the rocky surface below your feet, bobbing the sea urchins and fish to and fro. There are other people there, each immersed in their own thoughts.
No, that’s not a Dungeons and Dragons session starting. It’s the end of a great conference of workshops in Rovinj, Croatia, in the same spirit as last year’s.
PHP Summer Camp 2015
PHP Summer Camp is a dual event comprising of two PHP tracks and one eZ Publish track, the workshops of which are collectively called EZ Summer Camp. This year’s event took place slightly earlier than last year’s – from August 26th to 29th.
I attended in an entirely unofficial capacity this year. With zero responsibility on site, it was quite a different experience. This year’s key takeaways from the conference itself are:
- Doctrine is less complicated than it seems, just awkwardly documented
- Blackfire is less complicated than it seems, just awkwardly documented
- More people need to read Ross Tuck’s guide to conference speaking
- Puli is either the next game changer or the next big flop
- If you’re only attending conferences you get invited to (and your schedule is not packed with those invites), you’re not a good member of the community
- Tech people can and do have fun and interesting conversations in bars without getting drunk and awkward, contrary to popular belief.
PHP Summer Camp is not the typical conference where you sit and listen to someone regurgitate stuff they’ve written 3 years prior and never changed. This isn’t about “Getting to know Composer” or “Never trusting user input” – this is an event of exclusively hands-on stuff, little to no narrative, and constant direct interaction with the speaker. As such, there are very few workshops per day, but all are long and highly technical (shortest is 1.5 hours). I had the chance to attend five:
Doctrine: Get to work with mapping, queries and relationships
I had never had the need to use Doctrine in a project. I was raised on SQL, and any problem that needed a solution was easily SQL-able. When something needed optimizing, I gladly dove straight in and played with indexes, explains, and merging of statements into optimized chains of chaos. As such, with its apparently high learning curve, its tendency to use annotations to make logical decisions, and the prevalence of magic, I actively avoided it.
This workshop, by Sasa Stamenkovic of KNP University, offered a fantastic opportunity to get a birds-eye hands-on look at the thing without wasting days on reading documentation. The workshop itself was indeed very basic, and a lot of the time was consumed by the “curse of the first” in which the first workshop is always the one to have the most initial setup problems, but I do feel like I’ve come away with some useful knowledge and a better perspective of where Doctrine can actually be useful. I still doubt I’ll ever need it, but it’s good to be somewhat familiar with it now.
Sasa was much better and more confident than last year, but still needs work if he aims to surpass his mentor – Ryan Weaver.
Modernizing the Legacy
Marek Matulka from SensioLabs UK held this short form workshop on modernizing legacy code.
Although most of the content was very familiar to me due to Paul Jones’ book, I believe Marek pointed out some important ideas – particularly the fact that one should modernize concept by concept, rather than file by file, something a group of us had been discussing not an hour earlier.
There were no technical hiccups, but due to the speaker’s accent and volume (he had developed con-flu and lost his voice) and the brevity of the workshop, it felt a bit scarce and at times hard to follow. I would sooner recommend people read Paul’s book and get this content (and more) from there.
Frontend as design to backend middleware or some JS concepts that any good PHP dev should know
With a mouthful of a title, this workshop over-promised and under-delivered. Damir spent the first ten to fifteen minutes reading directly from the slides and looking at the big screen instead of the audience, which made it seem like someone else had written the content. After a hiring pitch (which traditionally comes after the talk) he dove into the code.
If this conference had a JS track, I would understand this return to JS basics being hosted there. However, knowing about the various more interesting talk topics that have been submitted, I wonder what made the organizers pick this one.
Loose Coupling in Practice
In this interesting workshop, Jakub Zalas used a Symfony application that was tightly coupled with Doctrine to completely decouple it and extract the Doctrine implementation into something injectible and replaceable.
Being severely underexposed to both Symfony and Doctrine meant it was a bit difficult to follow at times, but this was alleviated by an excellent organization of the tutorial through Github step branches which allowed those of us who limped behind others to skip ahead and check the solutions.
Learn PHP for free!
Make the leap into server-side programming with a comprehensive cover of PHP & MySQL.
RRP $11.95 Yours absolutely free
Jakub’s delivery was excellent, and his workshop’s code will definitely find a permanent place in my arsenal of helpful shortcuts for when I encounter Symfony and Doctrine again.
Next-gen Package Development with Puli
Bernhard Schussek, a veteran speaker and Symfony Forms master, presented his latest child – Puli. We’ve got an introduction into Puli coming up soon on this channel, but to cut the long story short, Puli is an “addon” for traditional packages which allows one to define common resources for use with those packages.
It’s a bit hard to explain in a few short paragraphs, so it’s best if you check out the slides. The one thing that sets Puli apart in a sea of PHP packages is that it’s one of those with the potential to make a huge paradigm shift in package development, much like Composer did years ago. If many people adopt Puli, we’ll have unparalleled compatibility between packages and frameworks and extreme reusability unlike anything we’ve seen before. Then again, it all depends on adoption and popularity – which is something I hope we at SitePoint can help with.
As usual, Bernhard’s delivery was almost flawless save for a few technical hiccups at the start which prevented us from taking full advantage of the entire workshop.
Profiling PHP Apps
In this workshop by Nicolas Grekas, we looked at Blackfire and everything it can do to help one optimize a website. The biggest barrier in my usage of Blackfire so far has been actually getting it to run – once we covered that some config wizards need to be run and about half a dozen
ini files need changes, we were up and running and Blackfire was drawing some crazy graphs all over a sample Symfony application.
Through Nicolas’ workshop we learned to analyze the graph, find the bottlenecks and remove repeated calculations. We’ll definitely be looking at Blackfire a lot here at SitePoint in the following couple of months.
One downside to this talk was that due to Nicolas’ accent, he was difficult to understand at times. We were able to follow the code, but I could notice the look of confusion (immediately followed by a “let me copy from your screen” look) on many a face during certain quickly pronounced sentences.
On the technical side, the organization was as excellent as last year in some areas, and less so in others.
Last year, the organizers provided us all with a virtual appliance – a fully configured virtual machine, which we used for all workshops. This worked well enough and everyone – from Windows to Linux users – was able to effectively use it, despite it being somewhat unorthodox (Vagrant would be preferred as a common starting point for such large teams).
This year, Vagrant was used and for the most part worked like a charm. However, it seems like it wasn’t tested enough on Windows machines, leading to some difficulties with Windows users. What’s more, NFS was forced as the sharing mechanism, which was unnecessary on some machines and required the admin password, slowing the provision process. It would have been better to leave it at auto – these days, Vagrant is smart enough to pick the best one, based on OS and availability of drivers.
The provisioning process was left in-box and excluded from the bootup procedure, which was odd but worked decently well, but on almost every workshop we had to do a
git pull to refresh the code, and then a
composer install to install dependencies. The pulling was necessary due to some delays introduced by the speakers (I would recommend the organizers hire a “poker” next year – someone in charge of poking the speakers about the status of their talk on a daily basis, from acceptance to opening day). Expecting to have to
composer install is perfectly natural, but having 200 people do it at the same time isn’t sane – not when 60 per group are pulling in the same packages. The installation shenanigans could have been avoided with a Toran Proxy which could have been hosting local copies of all the packages, thus speeding up the installation procedure to near zero.
There were some other oddities with the VM setup, but all in all it worked very well and everyone was able to follow along once the initial hiccups were ironed out.
The internet connection was as stable as last year, perhaps more so considering there were only a few hiccups and the attendance was significantly greater than in 2014.
Each day of the conference had some extras included, as well. A particularly interesting challenge was holding a part of a “triathlon” every morning for those who were interested in participating – the first morning was dedicated to swimming, the second was cycling, and the third was running. Each evening also ended in casual drinks, dinner and conversation, sometimes accompanied by a complimentary wine tasting as well.
The last day, post-conference, was traditionally dedicated to a boat ride. This time, we went to Porec, a medieval town on the coast, had a full tourist-like tour, and then free roamed before devouring some complimentary fish on the boat ride back. After some open-sea swimming and slo-mo dives, we headed home.
If you’re interested, you can see all the photos here.
Once again, Netgen delivered. The organization was flawless, and all the guests were made to feel very much at home. With quality workshops, excellent discussions, roundtables, hangouts and all the other extras, the conference contributed more than just hands-on coding knowledge – it contributed to the creation of new friendships, partnerships, and in-depth discussions on anything from scrum to BDD and more.
Are you coming next year? You should. And if you’re a speaker – start working on those workshops so you can submit proposals on time; it’s a bit more effort to deliver them, but it’s that much more appreciated by your audience.
Visual Studio Code: End-to-End Editing and Debugging Tools for Web Developers
Your First Year in Code
Jump Start Git, 2nd Edition