SymfonyCon Paris 2015

10 years of Symfony Fabien Potencier

10 years of Symfony

When E-commerce meets Symfony Marc Morera

The e-commerce is one of the main points of modern software. The e-commerce sector is growing about 15% annually, which is why it deserves special attention from software engineers. Speaking of e-commerce and open source at once is not easy. For many years we have identified the concept with pain and despair, so we must work urgently to change the way we understand it should be. What are the important points to consider? Where do we find the line between architecture and pragmatism? Are we walking in the right direction? How can Symfony help in this?

Dig in Security with Symfony Sarah Khalil

Security in Symfony is often misunderstood. Let's have a look at what is really happening behind the opaque configuration of the Security Bundle. Then we will see how it is possible to implement any way to authenticate a user in Symfony without third party library.

40 ms: How HSNG delivers personalized e-commerce with Symfony and Magento in the blink of an eye Magnus Nordlander

When you're building an e-commerce site, speed matters. You can measure the increased conversion rate brought on by increasing the speed of your site. To achieve speed, our greatest tool is caching. This caused concerns when HSNG, the largest sports nutrion retailer in Northen Europe, wanted to personalize their content, as personalization is the great foe of caching. In this case study Magnus Nordlander from Fervo and Patrik Wallin from HSNG will explain how HSNG uses Symfony, ESI and the eSales personalization platform in HSNG's Magento Enterprise store, to deliver personalized content in as little 40 ms.

Move Fast, Break Less: From DevOps to NoOps with Platform.sh Fred Plais

Big enterprise used to be slow, smaller actors used to be fast. Developers used to develop features, now, they code those .. and the infrastructure. DevOps may well have "Dev" in it, but nobody writes unit tests for their Jenkins scripts. Hack, half of the time these aren't even committed to git. But can you afford not to do DevOps? Can you afford to be slow? On the brink of 2016 we will cover in this short roller-coaster talk _everything_ that a team building web applications needs to cover to stay competitive. From the monolith vs micro-services and twelve factor apps, API and Mobile first applications, automated operations and continuous deployments to security management, scaling and internationalisation. Yeah, and we will also tell you what Platform.sh, the enterprise grade Platform as a Service for PHP, does to make all the pain go away: and how Friday afternoon is as good a time as any to deploy.

Continuous delivery, testing in prod, autoscaling and business workflows for a SF app in the Cloud Benjamin Talmard

Deploying applications in the Cloud allows developers to leverage DevOps features like continuous delivery, testing in production, autoscaling and so on without ever worrying about infrastructure. In this session, discover how Azure, the Cloud platform from Microsoft gives you this kind of flexibility for your Symfony applications.

The cloud is the future, and your architecture isn't ready David Zuelke

The advent of PaaS and Docker means developers need to change the way they build applications. Deploys that assume server state is preserved; application installers that handle configuration, database setup and generating of fixtures in one sweep; frameworks that cache configuration values from the environment forever - these approaches are incompatible with the containerized, elastic, on-demand infrastructure that is the future of the Internet. System designs of today still too often assume that durability is a responsibility of server administrators (or devops teams), and couple architectural elements tightly together in Chef or Puppet recipes that are brittle and hardly portable. Tasks that could be executed in the background get run synchronously, forming a barrier to scalability. Intermittent failures cause catastrophic outages instead of graceful ones. With all this, a central promise of the cloud can not be leveraged - reliability and scalability.

Building high profile webapps with Symfony and API Platform Kévin Dunglas

Speakers: Kevin Dunglas and Fabien Gasser. In a first part we will introduce semantic and linked data technologies supported by Symfony and API Platform: JSON-LD, Hydra and Schema.org, their contributions to interoperability and a web of data and how to use them, technologies until there the restricted domain of Java such as RDF, SPARQL, triple stores, ontology engines. In a second part we will give a feedback on the strategy we employed to build a high traffic CMS platform using Symfony, API Platform and AngularJS as technical stack. We will see how an API-first strategy helped us to deliver fluently content on several channels (desktop, mobile apps, connected devices, partners…) and how that strategy helped us to make large teams working together on the same project. We will also see how to leverage Varnish and AWS to absorb gigantic traffic peaks, how pure-JS fit well with that architecture and effects on SEO In a third part we will give you some tips in order to build an e-commerce platform based on that approach.

Symfony routing under the hood David Buchmann

Routing is this thing about mapping URLs to controllers, right? But in fact, there is a lot going on. Understanding the routing process will enable you to write more flexible code and keep logic out of your controllers. In this talk, we will see how routing actually works and then look at extension points like ParamConverters, custom request listeners and have a look at the CMF dynamic router that loads routes from databases or other sources on the fly.

Rethinking Extension Development for PHP and HHVM Jeremy Mikola

When MongoDB and its PHP driver first appeared on the scene, the GoPHP5 movement was just winding down, PHP6 books were on the best-seller list, and developers were handling dependencies with a mix of PEAR and Git submodules. After six years, our beloved driver had become quite the complex, monolithic extension, and PHP 5.x was no longer the only platform on the block. With the goal of supporting multiple platforms (PHP 5.x, HHVM, and PHP 7) while still keeping our maintenance burden in check, we set out to create several new light-weight extensions and pushed all of those user-friendly, high-level APIs off to a single, supporting PHP library. This session will walk through our journey and provide a fresh look at the next-generation MongoDB driver for PHP.

How Symfony Components boost the next generation of TYPO3 Benni Mack

The enterprise content management system TYPO3 is around since 1998 and has seen several migrations to stay up-to-date on PHP standards. With the latest version TYPO3 v7, several previous "home-brewed" parts of TYPO3 have been standardized and replaced with 3rd-party libraries especially from the Symfony Framework. The talk will focus on the "why" and "how" of standardization and encapsulation inside a PHP software as well as the benefits of integrating Symfony Components into the core and making parts of TYPO3 interchangeable. Next to Symfony Integration, I will also show the interchangeability of parts of the system with the new PSR-7 HTTP protocol.

Doctrine 2: To Use or Not to Use Benjamin Eberlei

Using Doctrine 2 can be a very rewarding experience, extremely frustrating or anything in between. To be a happy Doctrine 2 user requires attention and willingness to compromise. In this talk I will show how to use Doctrine defensively, common pitfalls that hurt maintainability and when to avoid Doctrine altogether.

A Journey Down the Open Road Yoav Kutner

Sharing the experience of managing an Open Source Project like Magento, some of the key decisions we made that lead to Magento becoming the leading eCommerce application in the world and the challenges, failures and successes we had.

Guard Authentication: Powerful, Beautiful Security Ryan Weaver

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 and introduced in Symfony 2.8. 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.

20M users in 19 countries with Symfony2. Olivier Dolbeau

3 years of work with 25 developers, 3.000 classes, 325.000 LOC: Symfony2 is more than ever present at BlaBlaCar. We would like to show you our website, its strengths and weaknesses, our most beautiful success and... our most extraordinary failures! We would like to apologise for all horrors which will be mentioned, all the crappy code which will be shown and the American happy ending!

How Symfony 3.0 moves forward without letting anyone behind Nicolas Grekas

Migrating from Symfony 2.3 to the newest Symfony 3.0 won't force you to rewrite all your application. Instead, you'll follow a well documented and continuous upgrade path to make a smooth transition. How is this possible? In this session, I'll tell you how the BC promise enables easy migrations. I'll also tell you about the creation of the new deprecation policy introduced in Symfony 2.7. These are the two corner stones that allow Symfony to do the split: having a wide range of stable apps and innovating at the same time.

Matters of State Kris Wallsmith

Subtitle: Using the Symfony Event Dispatcher to turn your application into a simple state machine If you have used Facebook's React library, then you are familiar with the concept of application state. React components are, at their core (and as noted in the official documentation), simple state machines. This declarative approach to building a UI may take some adjusting to, but it ultimately simplifies kludgy imperative code into smaller, much more manageable pieces. This pattern of manipulating state and responding to those changes can be implemented to great effect using the Symfony Event Dispatcher. This talk will step through this state-based approach to building an easily maintained and testable PHP application, tease out a few gotchas, and share real-world applications.

Breaking Boundaries with FastCGI Andrew Carter

Efficient applications are fantastic; they keep server load, costs and response times low. We can make Symfony applications more efficient by removing the repetitive bootstrapping process from the request-response cycle. By using FastCGI we can keep our application alive between requests and vastly improve their performance. The best news is that adding a FastCGI interface to your Symfony (or Silex application) can be done very quickly! Let us not get too excited, however! When using PHP in this way we have to be very careful about the design and configuration of our application! This talk will explain how to use FastCGI with Symfony safely, providing an overview of the process and highlighting the danger areas that we must be cautious of.

Blackfire.io - A Symfony project like no other Tugdual Saunier

Blackfire.io is a Symfony project. But it's only the tip 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.

Lightning fast Symfony tests Jakub Zalas

One of the benefits of having an automated test suite is the feedback given when the code is being changed. As a project grows, the test suite becomes slower and slower every day, until it’s so slow it stops being useful. Learn how to structure your Symfony project to benefit from lightning fast tests. Apply the right amount of testing on appropriate levels, and run your tests in seconds, not hours.

New Symfony Tips and Tricks Javier Eguiluz

The amount of Symfony documentation and learning resources is overwhelming. However, its relentless pace of change makes it very difficult to keep updated on all its features. In this session you'll discover lots of new tips and tricks about Symfony and its entire ecosystem, including Twig, Monolog and Doctrine. Learn how to improve your day-to-day productivity and discover some rarely used options and features.

"Perfect" caching with FOSHttpCache Andre Rømcke

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.

Comparing Symfony2 perfs in PHP7 migration julien pauli

PHP7 is released, and promises many performances improvements. Let's profile together some classical Symfony2 code, and see the performance differences between PHP5 and PHP7. Using the Blackfire tool, we'll compare performances of different Symfony2 components, as well as different Doctrine2 scenarios, into a Symfony2 web application. We'll then detail together the internal technical parts of PHP7 that made such improvements possible.

3 Steps to Symfony2 Form Mastery Bernhard Schussek

The Symfony2 Form component makes form processing a snap. It features a very flexible architecture and a myriad of configuration options that you can use to implement a wide variety from simple to very complex forms. However, knowing how to use this effectively can be a challenge. This session will give you a deeper understanding of the inner workings of the Form component and show how master the component in three simple steps.

Symfony: Your next Microframework Ryan Weaver

Microservices are a huge trend, and microframeworks are perfect for them: put together just a few files, write some code, and your done! But Symfony is a *big* framework, right? *Wrong*! Symfony can be as small as a *single* file! In this talk, we'll learn how to use Symfony as a micro-framework for your next project. Your app will stay small and clear, but *without* needing to give up the features or third-party bundles that you love. And if the project grows, it can evolve naturally into a full Symfony project. So yes, Symfony can also be a microframework. Tell the world!

Behind the Scenes of Maintaining an Open Source Project Jordi Boggiano

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.