Confoo, here in Montréal, has been one our go-to conferences for our developers.

The conference bills itself as a not-for-profit, multi-technology 3-day event. It's grown exponentially over the past few years, and boasted 600 attendees from around the world, and a staggering 145 sessions/9 concurrent streams for 2014.

This year, Patrick and Sean attended. Here's a bit of what each of them experienced:

Pat's view:

"Having attended for the 2nd time in a row, a lot was familiar this time around: same venue, same general scheduling and even a number of familiar faces. Similarity is a good thing because this conference is well managed and executed. The 2014 edition overcame some of the issues with 2013 which I’ll dive into a bit later.

With 9 concurrent streams over 3 days, it’s hard to have the exact same experience as anyone else. With that in mind, the topics are spread out in a way that there aren’t too many sessions you’re dying to go to at the exact same time. I was often lucky in having a choice between 2 strong options per timeslot, but not disappointed that I had to pick between them.

Overall, most of these talks were quite strong. The speakers were generally quite good and knew their subjects well. From a technology angle, nothing was “mind-blowing”, but instead interesting or it helped reinforce some of the concepts we employ. There was no resounding “omg, we need to use X”, where the focus was a bit more about how to manage legacy projects and adjusting overall process and approach to programming."

Pat's talks attended:


  • Application Logic Security
    by Ilia Alshanetsky (Centah Inc) slides
  • Learn Fast Web Development With Django and Python
    by Pedro Kroger (freelancer)
  • The InnoDB Storage Engine For MySQL
    by Morgan Tocker (Oracle) slides
  • Optimizing your JavaScript
    by Wendy Liu (McGill undergrad) slides
  • Clean Application Development
    by Adam Culp (freelancer, SunshinePHP) slides


  • AngularJS is the future. Maybe.
    by Alessandro Nadalin (Rocket Internet)
  • My site is slow, what can I do? - Profiling PHP applications
    by Bastian Hofmann (ResearchGate) slides
  • The Setup: Composer, Phing, Vagrant, Jenkins
    by Stephan Hochdoerfer (bitExpert AG)
  • Don't Be STUPID, Grasp SOLID
    by Anthony Ferrara (Google) slides video
  • Unbreakable Domain Models
    by Mathias Verraes (Ausy/Dataflow) slides
  • First Steps in Android Application Development
    by Sasha Goldshtein (SELA Group) slides


  • Marrying front with back end
    by Bastian Hofmann (ResearchGate) slides
  • Offline Mode
    by Patrick Leckey (In-Touch Insight Systems) slides
  • Designing JavaScript APIs
    by Jonathan LeBlanc (Paypal) slides
  • Leave your '$' behind
    by Fabien Doiron (Crated/CanvasPOP) slides
  • Real World Retrospectives
    by Sean Yo (Desire2Learn)

Sean's view:

"Since Pat discussed the event in general, I will try to dig into the talks I went to see what useful info I can bring back to the Plank team. Pat and I ended up having a lot of crossover in terms of choices of talks. Though there were 9 concurrent streams, one can only keep track of so many languages at a time so we ended up with a narrower set of choices. I tried to pick talks regarding both front-end and back-end discussions, with topic mix of optimization, best practices, emerging technologies and new workflows.

As Pat mentioned, we didn’t really feel any of the new technologies were essential, but I picked up quite a few best practices that I either wasn’t aware of, didn’t fully understand, or wasn’t taking full advantage of before. Here are some things that I took note of:

Backend Optimization

  • Avoid using PHP Sessions since it is saved to disk. Making use of Databases, Memcache/Memchached or an encrypted cookie may be faster.
  • Cache all the things! Expensive queries or operations should be cached at the application level (we already do), all resources should specify HTTP cache headers for client-side caching and something like Varnish could be used at the server level. Don’t forget to leverage cache expirations and/or invalidation.
  • One way to deal with extremely heavy server-side tasks is to perform the bare minimum needed to generate the next page for the user and enqueue the expensive tasks to be performed asynchronously once the server is free. There are a number of services for this, such as Resque.

Frontend Optimization

  • In JS, you can provide a function name for closures – they don’t need to be anonymous. This can help make the code self documenting and easier to read, but will also create more verbose stack traces when debugging. Example:
    $(document).ready(function domReady(){...});
  • Avoid creating closures inside of a loop. Cache the function in a variable outside of the loops scope. Common knowledge, but it is very easy to get lazy here.
  • If applying many changes to an element through JS (i.e. multiple styles, etc.), detach the node from the DOM first, apply the changes, then re-append to the DOM tree. This will prevent the browser from calculating multiple layout reflows. I would expect that setting CSS display:none would have a similar effect.
  • Javascript animations should be restricted to absolute or fixed elements, where possible, to prevent repeated reflows/repaints of sibling and parent elements.
  • IE and Firefox both use a hybrid of garbage collection and reference counting for memory management, which makes them prone to memory leaks. Be very careful to avoid circular references between objects. Closures make it easy to create leaks as one may not be aware what outer variables may be retained by the closure.
  • jQuery may be overkill for some projects. It provides a nice interface for programming, but for some projects the performance hit may be too significant. The API and browser support for native javascript has come a long way.
  • Patrick Leckey’s talk went into great depth regarding the LocalStorage and ApplicationCache APIs. For some of our more web app-style projects, leveraging these could be a great way to make the site connection-independent."

Sean's talks attended:


  • Development By The Numbers
    Anthony Ferrara (Slides)
  • Browser Eyeballing != Javascript Testing
    Jordan Kasper (Slides)
  • Scaling PHP in the real world!
    Dustin Whittle (Slides)
  • Optimising your Javascript
    Wendy Liu (Slides)
  • Clean Application Development
    Adam Culp (Slides)


  • AngularJs is the Future. Maybe
    Alessandro Nadalin (Slides)
  • What makes me "Grunt"
    Fabien Doiron (Slides)
  • The Setup: Composer, Phing, Vagrant, Jenkins
    Stephan Hochdoerfer
  • Speed up your Database
    Anna Filina (Slides)
  • Unbreakable Domain Models
    Mathias Verraes (Slides)
  • First Steps in Android Application Development
    Sasha Goldshtein 


  • Marrying Front with Back End
    Bastian Hofmann (Slides)
  • Offline Mode
    Patrick Leckey (Slides)
  • Designing Javascript APIs
    Jonathan Leblanc (Slides)
  • Leave your '$' behind
    Fabien Doiron (Slides)
  • Real World Retrospectives
    Sean Yo (Slides)


See you at Confoo 2015!

Design & Code Events