SymfonyOnline June 2023

Keynote: The Scheduler Component (Fabien Potencier)

Symfony 6.3 comes with a new Scheduler component. Let's discuss it and discover the excellent community work since the initial PR was merged.

Is SOLID dead? Let's discuss reusable software design (Łukasz Chruściel)

In his publication describing CUPID principles, Dan North begins with the question, "If I do not think the SOLID principles are useful these days, then what would I replace them with?". This got me thinking about what I think of SOLID and how I look at it. In my presentation, I would like to break down this acronym into its components, test its usefulness with examples (based on a Symfony-based app), and consider what we can take from it. I will also try to answer the question posed in the title of the presentation.

Optimize your software with API first (Max Beckers)

Building software has the purpose of processing data - data flows into systems or must be made available to others. This is why we need APIs and this is at the core of the API first approach. The focus is on the API from the beginning. In today’s approaches we often think in microservices and headless backend systems - two approaches that pushed the API first thinking. What changes in the development process? How does the quality of the software increase? And how does API first make all stakeholders happier? I will try to answer these questions in my talk. I also want to show some practical tips and tools for APIs.

Let your end users be creative with the ExpressionLanguage component (Florian Merle)

The ExpressionLanguage component has been around for quite some time, and its usefulness is no longer to be proven. Many popular projects like OroCRM, Sylius, or Symfony itself use it. This component can be seen as a PHP sandbox and is mainly used to set up an application by allowing for advanced configuration. It can also be used as an engine to implement business rules. Indeed, by using the component in this way, it is possible to let end users write configurations in an understandable, secure, and dynamic way. This last aspect is really interesting and is what I want to explain. During this talk, we will re-discover the ExpressionLanguage component by getting an overview of the conventional way it is used. Then, through a concrete example, we will see the real potential of this component. In an e-commerce context, we will create a system that allows administrators to write business rules. These rules will dynamically apply promotions. At the end of the talk, we will know how to use the ExpressionLanguage component to let end users build their own business rules.

Firefighting a Symfony & Elasticsearch app with Blackfire (Emanuele Panzeri)

This talk will cover the journey and findings of firefighting a complex Symfony application (with Messenger, Serializer, Varnish, Redis, RabbitMQ, and Elasticsearch) with Blackfire. The topics covered will be: - Bottleneck within the Serializer - Caching serialized object - Digging into Elasticsearch APIs and some internals To finally find the root cause of a spike of http-500 errors in a public facing API with 2M requests. All of that by using the Blackfire profiling features.

Taming the Forking Beast: Refactoring Monolithic Projects (Marine Gandy)

Once upon a time, great people created a great Symfony demo, to be used as a living code example and help us all learn: Bigfoot. Since then, the DevRel team at Platform.sh has forked this repo and created a really fun escape game to showcase Blackfire. And we thought it would be good to have a dedicated frontend for our game, instead of reusing the Bigfoot design. So we forked it to create an instance for Django. And then we forked it again to make an instance for Drupal. And then another fork, and another. Slowly, we realized that the way forward was to refactor our dear monolith to better fit our needs. Let me show you how we stopped forking around!

Teaching Doctrine to be Lazy (Kevin Bond)

Doctrine object managers are greedy: when you query for a set of objects, they love to load everything, all at once. That’s normally great - but what if you’re working with large data sets, where you might load 10's of thousands of objects? In this talk, we’ll teach Doctrine how to be lazy by demonstrating how to efficiently query and work with large data sets. We’ll cover: - Lazy queries - Lazy relationships - Profiling and reducing object "hydrations" - Efficient batch processing - An alternate, “lazy-by-default” repository pattern

AssetMapper: Manage Your JS Deps Without Node (Kévin Dunglas)

Yarn, NPM, pnpm, Babel, SWC, Webpack, TurboPack, Rollup, Parcel… Is it really necessary to introduce so much complexity to create a beautiful and interactive website? The Symfony UX initiative greatly simplified how to build frontend applications with Symfony by going back to the roots: server-side generated HTML (goodbye JSX, our good old Twig is back), and minimalist JavaScript thanks to Hotwire. However, to use Symfony UX, you still need to install, set up, and maintain an entire JS toolchain… which is no picnic. Is it still really necessary?! Browers recently gained features making it possible to do without most of them. Let’s see how to get rid of the complexity by using the web platform… and the new Symfony ImportMap component!

Here comes Symfony 6.3! (Nicolas Grekas)

A lot has happened in the last 6 months. Are you excited about Symfony 6.3? Many are! Even if you follow the activity on the GitHub repository, I'm sure you've missed something that could be invaluable for your next project update. Let's have a look at the progress we made together as a community of contributors.

Tests in a Symfony application (Alexandre Salomé)

Writing tests for a project is the guarantee for development efficiency and the software delivery chain. In Symfony, we use PHPUnit to do so, and we have many tools in the framework to achieve this goal. Using the documentation, we quickly ask ourselves: how can I have a maintainable test suite? Should I write a unit test or a functional test? How to handle dependencies to third services? How to test the mail sending? How to organize my test data? At this conference, I will address those questions and provide an exhaustive tour of the Symfony features you can use in your tests.

Asynchronous juggling with Symfony HttpClient (Allison Guilhem)

Making HTTP requests is a common practice, but managing their responses can quickly become a performance bottleneck. In this talk, we will explore a little-known tool, the AsyncDecoratorTrait feature of the Symfony HttpClient component, which provides more flexibility in handling request responses while preserving asynchronicity. We will discuss the application contexts in which this tool is useful and its advantages and limitations, as well as how it differs from decoration at the request or response level. Are you ready to learn more about improving HTTP response management? Let's dive in!

Decouple Your Apps with Symfony Messenger (Alexander M. Turek)

Learn how to unlock the power of asynchronous communication in your Symfony applications with Symfony Messenger. In this talk, we will cover the basic concepts of message queues and asynchronous processing, and demonstrate how to integrate Messenger into your Symfony project. We will also discover how Messenger can be used with different queue implementations, making it a portable and flexible solution. By the end of the talk, you'll have the tools to write more scalable, portable, and resilient Symfony applications.

Design your API for the future (Titouan Galopin)

Designing an API is complex, the proof being the quantity of technologies invented to try to simplify and standardize it: REST, GraphQL, HAL, JSON-LD, Hydra... Designing an API for the future means ensuring its long-term stability: stability of input/output formats, versioning and deprecation management, inclusion of sub-resources, communication of changes to consumers... Let's discuss these challenges and how to address them in the context of a Symfony API.

DDD (Debugger Driven Development) (Carlos Granados)

Many developers fail to use a debugger like Xdebug in their day to day activities. In this talk we will explain: - Why you really want to be using a debugger - How do you install and configure it easily - How it interacts with your Symfony application - How you can use it for more than just debugging your application, how you can actually use it to drive your development.

Working with Pull Requests (Malte Wunsch)

Pull requests are one way to organize your software development process and to make it more robust. They are especially beneficial when working together remotely or asynchronously. They’re commonly used in open source projects like Symfony, but can be just as useful in closed source environments. But what makes a good pull request? A good review? How can we shape our environment to encourage good collaboration? In his talk, Malte shows what he has learned from the way Symfony uses pull requests, and gives some further ideas for setting up your environment, for writing, not writing(!) and reviewing pull requests.

Modern UIs with UX, a little JS & Zero Node (Ryan Weaver)

Ready to build a highly-interactive, modern UI? Me too! But hold up, do we really need to install Node & Webpack to pull this off? Not anymore! With PHP, Twig, and just a pinch of JavaScript magic, we can create something truly special. In this talk, we'll embark on a journey using the new Symfony UX experience, one *without* Node and Webpack. We'll conquer common UI challenges like modals, notifications, and filterable tables, wielding the power of Turbo & Stimulus while writing minimal JavaScript. For the grand finale, we'll tackle the most interactive situations using only PHP & Twig, thanks to the LiveComponents. With *huge* changes over the past few months, this is finally ready for the big leagues.