This is the video caption

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:

Wednesday

  • 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

Thursday

  • 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

Friday

  • 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:

Wednesday

  • 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)

Thursday

  • 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 

Friday

  • 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!

Want more? Join our newsletter.

We love sharing our latest web design tips, insights, and projects.

S’inscrire

Vous pouvez vous désinscrire en tout temps. Contactez-nous pour plus de détails.