jsDay & phpDay conference Verona 2016 review

Tony Mrakovčić, Bruno Zorić & Rudolf Jurišić

Every year we reserve a couple of days for Verona, to see what’s new, exciting and fresh on the development scene. 2016 was no exception, so here’s what we saw and who we heard!

Since jsDay and phpDay are conceptually different, they also have different themes.

For js, this year was mostly about making front end go to lightning speeds, falling back on stuff doing it right and generally the idea of replacing a native mobile experience with a web one, without losing all the perks that native mobile offers.

Php was more straightforward. Having in mind that php7 is really out there now and people are switching to it on a daily basis, the focus was not so much on raw performance, but on utilising that speed into doing new stuff – managing your framework’s full potential, securing stuff and successfully deploying it to production.


The JS keynote was held by Shwetank Dixit, who generally spoke about the idea of not needing native apps anymore. :)

He covered the concept of progressive apps through some good examples of pages and plugins, which you can use to make your mobile web have the look and feel of a native app. All that without having to compromise on any feature that native offers, like storing, pushing, offline use and almost any other feature that native has and web doesn’t. He also mentioned pwa.rocks as a nice resource for featuring and exploring progressive web apps that are already out there.

Something that was mentioned in probably 70% of all the talks in Verona were web workers and service workers which, although not that new, seem to be a perfect resource for switching cpu load from the main thread (for stuff like ui and heavy processes) to the background. Even though we still haven’t started to seriously use them in production at Degordian, I definitely see them in our near future.

Another thing that a few talks had in common was the general improvement of CSS/JS transitions and animations.

The gist was basically:

  • “Use the GPU and not the CPU for that kind of stuff!”
  • “How do I use the GPU”
  • “Force the thing into using 3d”
  • “But won’t that deplete my battery!?”
  • “Yes!”
  • “No, but seriously, use the GPU and some other css tricks to save the battery and it’ll be a great & smooth 60fps experience for everyone!”

Animation, audio & apps

While we’re at the subject of animation, there have been a lot of devtools extras regarding animations and transitions added, that I wasn’t completely aware of! Stuff like “enable paint flashing”, that shows you how the browser struggles to repaint pixels instead of translating them and saving precious FPS. Animation slowing and animation timelines(with SCREENSHOTS!) can effectively show you what exactly is causing that little twerk that “sometimes” happens when a fast animation is happening, while an FPS meter can show you when stuff is transferred from the CPU to the GPU.

We saw there are a lot of forgotten stuff that people, for some reason, just aren’t using in their apps. For instance, there’s a very capable audio and MIDI (!) web API that can process music, midi and live audio on the fly, and use them for very, very interesting things. I must mention Ruth John who, in spite of having audio problems with the tech crew, managed to VJ the thing and bring out the real power of webAudio and webMIDI APIs. She combined web-based old style Winamp visualisations and He-Man (yes, the cartoon) with a midi controller.

Another interesting speech was actually from one of our former employees, Fatos Hoti. He talked about the development experience of making and maintaining an app using the concept of single source multi platform app (web, android and iOS) using react native. Debugging, inspecting and hot reloading content as well as source for all three in a live demo.

Just a little more JS

Day two started with a keynote on VisualStudioCode from Alexandru Dima. It actually looks like a nice piece of software. It’s like Microsoft is sorry for some things they made developers do in the past (we all know what I’m talking about) and is now producing big stuff that helps the whole community. VisualStudioCode is a must try, but we’ll see how it holds up :)

As I’ve mentioned before, a good part of the focus was placed on optimisation. What optimisation without debugging and monitoring really is, was thoroughly explained in a nice talk by Andrew Rota. On the stage, he was followed by a great “16ms or bust” talk by Seth Samuel who explained what exactly happens when you use css the wrong way and (although it looks ok) how it fails to scale when other layout elements are introduced into the mix. And the nicely put “What is a microservice? It’s bigger than a nanoservice, smaller than a milliservice!” Well played, well played!

Umar Hansa gave a VERY comprehensive talk on how to debug and handle stuff using Chrome devtools, and he introduced us to a little thing called “dev tips” that is basically his site that sends out great developer tips in the form of a gif. :)

And I must mention one of the most “wat…” presentations of the event. It was a talk by Patrick Kettner, who used react-blessed and built a… wait for it… responsive… clickable… command line… web site… Yes… Wat… Exactly…


All this text, and we didn’t even touch PHP! Oh well, let’s see what they were doing on the server side.


The keynote for phpDay was held by Rasmus Lerdorf, the creator of php. He talked about php7, it was a little too graphy and numbery if you ask me, but the numbers are there. Php7 should performance-wise be better than HHVM. :) He also talked about correctly deploying to production and how you can actually decrease your server number to one third if you switch to php7 (from let’s say 5.6), which is a very interesting thing if you are on a cluster of 1000+ servers.

Nikolay Krapivnyy talked about the real problems of switching Badoo and other sites of that scale and what you could run into. He had a lot of good stuff there, including some software like https://github.com/vk-com/kphp-kdb, Pinba.org and Soft-mocks. This can really help you if you need to migrate a beast that big or if you just need to replace some testing and optimization flows.

One of the talks I was really interested in was the one by Paul Dragoonis. He and his team built something called PPI, the php metaframework. I’ll put their description here since I believe it’s the best way to explain it:

PPI is a framework delivery engine. Using the concept of microservices, it lets you choose which parts of frameworks you wish to use on a per-feature basis. As such, each feature makes its own independent decisions, allowing you to pick the best tools from the best PHP frameworks

In a nutshell, you can use any part of any framework, mix them together and it all works!

Another interesting piece we heard was by Damien Seguy. He talked about the process of using machine learning in native php. It may not be the best tool in the world for the job, but it can actually be done quite easily. The tool he was talking about was the Fann extension for php, which basically lets you make and train a neural network completely in php. Not bad. Not the tool, but not bad.

Jordi Boggiano, creator of Composer package manager, had a nice talk about regular expressions. He had some tips and tricks including naming matches in regex so you do not need to use indexed array but associative ( eg. $matches[ 0 ] vs. $matches[ ‘myMatch’ ] ), writing really long regex in multiple lines with x modifier, using unicode character classes, profiling regexes and mentioned a few nice tools like https://regex101.com and https://jex.im/regulex

There was also a nice talk about http2 and how things will get a lot faster once everyone implements it. Stuff like server push and multiplexing requests will be the next big thing!


Two talks focused on the concept of event sourcing. In a few sentences, event sourcing would be the methodology of writing data (be it in a database of otherwise). Instead of writing only the last known “state” of the record, you write down only the first object that needs saving and then subsequently only remember the differences that happened to the object. Using this approach, you can easily view any object at any timeframe you need, and also see all the relations to it in at any given time. This is a major oversimplification of how it works, so if you’re interested, read about it some more. :)

It is definitely something to dig into, depending on your project needs. They mentioned banks are always built on this kind of architecture, as well as git.


There was, of course, a php vs. IoT talk as there should always be. Although the idea is great and a lot of great tools like https://github.com/PiPHP/GPIO were introduced, the main motive of pouring glasses of Aperol Spritz was accomplished by direct current instead of a script, but hey, it happens, the demo gods were not on your side that day! :)

The main thing here is that we found some great stuff to use when developing with php and Raspberry Pi.


All in all, another great conference for Verona, Javascript and PHP, and another great accomplishment for the Grusp team that organizes the event every year. Kudos to them and to all the speakers, see you all next year!


Get more digital stories directly in your inbox.
Your email is saved
Join the discussion

No Comments

Share your thoughts

Let's work together  →
Go to top