The Ilios Project at the University of California, San Francisco has been hard at work for the past 6 months creating the next version of our application using Symfony and Ember. I will show you the bundles we've used to build a beautiful REST API and the bundles we've written to make generating the necessary boilerplate as easy as possible.

Next we will talk about strategies for serving a single page app through Symfony. I will cover the pros and cons of user Assetic, placing the built application in the /web directory and our final solution of using AWS Cloudfront to provide the javascript and css assets and AWS S3 and Symfony to serve the index.html file. This last solution has made it possible to build our webapp and API in tandem but with no friction.

None of this is theory and all of our work is open source so we will be looking at the code we have in production to manage the curriculum at dozens of medical schools on 3 continents.

I'll present how to tune Symfony webapps to be as efficient and as robust as possible thanks to cloud computing platforms.

I'll detail how to design the webapp from the start to be very efficient on such platforms: we we'll learn advantages of splitting the backend code (PHP/Symfony) from the frontend code (HTML/JS/CSS) communicating trough a REST API, how to build stateless apps (including auth) that play well with horizontal scalability, and what kind of services can help us to setup in hours a rock solid infrastructure without an army of sysadmins.

Then we will discover how to run a Sf webapp on Heroku + AWS without pain thanks to some tricks and a lot of useful Symfony bundles and PHP libraries.

In the end we will get a Symfony webapp with all assets stored on a CDN, running on Heroku with HHVM behind a reverse-proxy, in full HTTPS, able to survive under very high traffic.

During this session, we will have a look at how easy it is to override everything in a Symfony application. We'll see how the directory structure can be adapted to your needs, but more importantly, we will learn how to override any Symfony feature by writing some custom event listeners or by tweaking the Dependency Container configuration.

Promising increased flexibility & scalability as well as cognitively simpler implementations, microservices are gaining as an alternative to monolithic designs. Unfortunately, many have begun using them as a "golden hammer", failing to recognize complexities inherent in distributed systems. In this talk we'll review the case for microservices, explore common characteristics of microservice architectures, differences between microservices & SOA, and trade-offs between monoliths & microservices. Fight "microservices envy" by learning to use them selectively & appropriately in your projects!

At eZ we have been lucky to work with so many talented developers in the PHP and Symfony community, and one of the many projects we have so far contributed to and also benefitted from is FOSHttpCache. A super charged Http Cache implementation with tagging of content, varying of cache by user cache, support for Varnish, Symfony Proxy and Nginx, and much more. But it can still be improved, multi tagging support for Symfony Proxy, and Stale cache handling on purges by tags are two currently missing features for handling all possible high load situations while also being easy to use. Talk builds upon previous talk: Going crazy with HTTP caching - SymfonyLive Paris 2015

Blackfire.io is a Symfony project. But it's only the top of the iceberg.
By its very nature, Blackfire.io faces challenges that few Symfony projects have to overcome.

Managing a project with several languages like PHP, Go or C, releasing binary softwares to end-users weekly or synchronize development across stacks using different technologies are some of the challenges we face every day in addition to more usual ones for Symfony projects like logging, daily deployments or delivering features.

What did we do to become able to provide a complete binary releases of over 100 artifacts in less than twenty minutes?
How did we manage to produce over one thousand releases in less than an year?

In this talk I will give you a taste of what it feels like to work in such a stimulating environment as well as explaining how we are tackling these issues.

There are so many interesting ways to authenticate a user: via an API token, social login, a traditional HTML form or anything else you can dream up.

But until now, creating a custom authentication system in Symfony has meant a lot of files and a lot of complexity.

Introducing Guard: a simple, but expandable authentication system built on top of the security component. Want to authenticate via an API token? Great - that's just one class. Social login? Easy! Have some crazy legacy central authentication system? In this talk, we'll show you how you'd implement any of these in your application today.

Don't get me wrong - you'll still need to do some work. But finally, the path will be clear and joyful.

OroPlatform is a business application platform (BAP) based on the Symfony full stack framework. It is available as a standalone Symfony application, as well as a composer package that can be used in any Symfony application. Out of the box, OroPlatform allows developers to:
• Build flexible data models with multiple functions, including: Audit, Search, CRUD UI, Workflows, Reporting, and more
• Manage users and permissions
• Enable REST and SOAP web API
• Manage user configuration settings
In this talk, we will share our key learnings about building the application based on the Symfony framework, as well as use cases for OroPlatform.

Using Composer and Packagist makes using 3rd-party code easier but relying on 3rd-party code can have drawbacks. Projects are abandoned. Maintainers become unresponsive. Pull requests are rejected. Fortunately, Composer provides tools to help make these situations a little easier to manage.

Learn how to leverage Composer features like "replace" and tools like Satis to manage forks of 3rd-party packages. See pros and cons of various methods so that you can feel more confident in how you decide to move forward with decomposing other people's packages.

Rebuilding our Foundation: How We Used Symfony To Rewrite Our Application in Six Months

This talk is about how my company took a broken e-commerce and LMS site written in an older style MVC framework and re-wrote a significant portion of it in Symfony and related tools (Doctrine, FOS Bundles, Sonata) over 6 months and created a stable, well-tested application. I’ll cover the approach we took to rewriting the admin panel in Symfony, writing an API, introducing Behat and PHPUnit tests for both new and legacy code (still in a separate framework) and setting up Continuous Integration. I’ll discuss how we optimized the site as we went, by identifying weak spots in the code and how we addressed them. I’ll also cover what we would do differently now that we’ve done it once.

Symfony 3.0 is just around the corner. Are you ready to migrate? The Symfony core team created a continuous upgrade path for progressively upgrading current apps. In this session, I'll show you this path so you'll be able to migrate your own applications to Symfony 3.0.

Software bugs are inevitable - it doesn't matter how experienced you are or how well you follow best-practices. Some bugs are especially difficult to track down, causing you to waste countless hours before throwing your hands up in defeat. It doesn't have to be this way though! The mental fatigue and wasted time can be avoided by implementing effective debugging strategies like: identifying & using the most-appropriate tool; taking a logical & objective approach; challenging assumptions; listening to variables; isolating the code path; rubber ducking; and reinforcing code with automated tests. Attendees will learn how to combine these techniques with the right mindset and attitude in order to debug their code effectively.

The open source world is made out of human interactions as much as it is made of code.

During this session, Jordi will be sharing his experiences as the Composer Project lead. He will show you glimpses into what it means and feels like to be the maintainer of a popular open source project.

By sharing his experiences, Jordi hopes that you will gain a better understanding of the human factor in the open source community.