Schedule

Keynote

Content management is more than just adding a text editor to your project. Initially, you may only need a basic text editor for your Entity. However, as your project grows, you might require support for multiple languages, and when drafting or versioning come into play, things can get tricky.

In this talk, I will provide a quick introduction to different ways of data modeling and the libraries available to meet these needs. I'll also share a brief history of Sulu's content storage and explain why we decided to redesign the entire content storage system for a better future.

You'll learn how to evolve from a simple Doctrine entity to a translatable entity, and finally, to a multi-dimensional entity that supports multiple languages, drafting, versioning, and more. These concepts are reusable even if you're not using our beloved CMS.

Compressing HTTP responses can significantly improve the performance of your Symfony applications. But you still need to find your way through the jungle of standards and formats.

In this presentation, we'll discover how HTTP compression works, the different formats supported by modern web browsers (deflate, gzip, Brotli, and the brand new Zstandard), and how to use them correctly with Symfony.

We'll also look at which formats to compress, which not to, when to use dynamic compression, and when (and how) to pre-compress responses that can be compressed for even better performance.

Effectively managing forms can be a daunting task, given their diverse and complex requirements. This talk aims to simplify this challenge through a practical case study.

We will delve into strategies for handling dynamic forms, efficiently organising data, and structuring code in a modular and reactive manner. Special emphasis will be placed on managing collections, utilising data mappers, and implementing data transformers. By dissecting these critical aspects of form management, this talk aims to demystify the complexities associated with Symfony forms.

So, let's explore Symfony form handling and discover solutions to streamline your daily workflow effectively, gaining practical insights and tips for creating and maintaining clean, extensible forms tailored to meet the specific demands of modern web applications.

Symfony UX is a set of components for creating rich front-end interfaces with Symfony. This December, it celebrates its 4th anniversary. (Happy UX-Birthday!)

What a year 2024 has been for Symfony UX!

We’ll review all that happened: new components (Icon, Map), added features to TwigComponent and LiveComponent, and discuss the philosophy and directions taken by the Symfony UX team.

Then we’ll explore the future of Symfony UX with a sneak peek at 2025, including one or two surprises!

The deployment scenario for PHP looks a little different than for other languages like Go or Ruby that have embedded webservers. The classic stack of NGINX/Apache + php-fpm doesn't perfectly fit in the container world.

Some solution providers, like DigitalOcean or certain Azure products, only allow for single containers to be deployed.

In this talk, we'll explore ways other people have solved this, like FrankenPHP, Framework-X , and others. For production deployments, there is k8s, swarm, compose, and running everything in one multiprocess container.

These single containers could be orchestrated with systemd, supervisord, or Runit. We'll talk about the benefits and downsides of these solutions, compare them with the choice we made for our last project, s6-overlay, show off the s6-cli project I developed for this purpose and talk about recipes for running database migrations, cronjobs and a few more.

Serialization plays an essential role in any information system, and particularly in the context of a web application, as it is one of the pivots of the HTTP request/response cycle. That's why Symfony's Serializer component is one of the most critical for our applications.

Needs evolve, and since its creation, this old component has found itself confronted with new problems and has in some ways reached its own limits.

That's why it's now necessary to completely rethink the way we serialize data in the Symfony ecosystem.

So let's take a look at two Symfony component drafts: the JsonEncoder and the ObjectMapper, and how they interact to provide a brand-new way of serializing data.

Postgres is famous for its support for SQL data. However, Postgres also has powerful capabilities to work with JSON. I will show how to leverage the various JSON functions of modern Postgres to work with your less structured data. I will also show how to use some of that functionality from within Doctrine.

Looking at old legacy code, you usually know "a better way to do it" by now. But did you ever look at "the code in your mind"?
Let's go through a helpful mindset for refactoring projects and apply some principles of refactoring to yourself.
This talk will give you a better understanding of how you and your brain evolved from index.php to a complete fully grown application - and what parts of your brain still run legacy code.

Docker containers ensure consistent application behavior in different environments. However, they can be complex for those unfamiliar with containerization. DDEV simplifies this by abstracting Docker and Docker Compose, offering a standardized input layer but still allowing for customizations. In this talk, I will introduce you to DDEV and demonstrate how to install and integrate it into a Symfony project. I will also showcase how to extend DDEV and how you can interact with your Symfony application.

As your application evolves from a side project into a serious business, you will likely encounter situations where you, your support team, or even your customers question why certain configurations changed, why information is incorrect, or why data seemingly vanished "on its own." Understanding and effectively managing these issues is crucial to maintaining the integrity and reliability of your application.

This talk will explore various strategies for auditing data changes in Symfony applications. We will discuss where to begin and what factors to consider as the volume of data increases.

The Dependency Injection Component is a key part of all Symfony applications. It helps developers write decoupled and maintainable code.

In this beginner-level talk, we will explore the following:

- The principles of Dependency Injection
- Setting up and configuring the Symfony service container
- Using Attributes for service configuration

By the end of this session, you'll have a solid understanding of how to implement DI effectively, ensuring your Symfony applications are scalable, maintainable, and easy to test.

Mapping is something that you see in many frameworks over the web in every programming languages. Doctrine, for example, has a quite complex mapper to transform the relational database representation to your well-known entity.
After covering the history behind years of discussion and research by the Symfony community, we'll study the needs for such a component in Symfony. We'll analyse how different it is from the Symfony Serializer, and what are the solutions popular frameworks on the Web offer. At least, we'll showcase the new Mapper component and its application from API design to day to day use cases.

As software engineers it is sometimes too easy to forget the impact that our code has on the environment. We build for changeability, speed and hopefully quality, but we forget about sustainability. The time to act is now. It is time for us to take responsibility and to write more sustainable tech. In this talk I will talk about things we can do to write more energy efficient code. I will also talk about hosting your code more sustainably. And last but not least… I will share the software architecture needed to build greener applications using Symfony Messenger.

At SymfonyCon in Brussels last year, I caught you up on PHPUnit 10 and its sweeping changes. I highlighted the improvements that were made to handling E_(USER_)* issues, both in your own code as well as in the code of your dependencies. In the end, I expressed the hope that thanks to these changes Symfony's PHPUnit Bridge would no longer be needed one day.

Join me, the creator and maintainer of PHPUnit, to learn everything you need to know about PHPUnit 11. You will experience new features, big and small, in action and see how they can support you to effectively and efficiently test your software.

Of course, we will also discuss whether Symfony's PHPUnit Bridge is still needed ...

I truly believe Dagger is the next evolution of CI/CD implementation. Myself, as a subject matter expert in CI/CD, I spent years building the perfect system to mitigate challenges we face at a tech level and business level. Now along comes Dagger, created by Solomon, the founder of Docker, and it makes so many challenges disappear, by design, and opens up so many new possibilties along the way.

In this talk I'll be your guide in a deep dive into Dagger-land, demonstrating how to strategically start integrating this into your existing projects and start benefiting from the awesomeness.

We are in March 2013. Symfony 2.2 has just been released, PHP 5.5 is around the corner and I give my first public talk during a SymfonyLive: “42 best practices for Symfony” (in French).
10+ years later a lot of things changed for Symfony, for PHP but also regarding development in general.

Let’s take a moment to look back at those best practices and see which one are still relevant, obsolete or now completely wrong. This would be a nice opportunity to reflect on the evolutions our ecosystem experienced over the last decade.

Since wkhtmltopdf was deprecated, it is difficult to find an easy to use / setup library to generate PDF's.
Amongst the existing solutions, we chose to focus solely on Gotenberg.

The existing SDK did not match our needs as it provides only static classes, so we decided to give a try and create ourselves a brand new Bundle with the DX possible for Symfony Developpers & PHPStorm users.

From the fast HttpClient to the forgotten Webhook, let's see how existing components can help us to make PDF generation fast and easy to use.

To do so we had to ask ourselves a few questions which we will cover together !

How do we expose a friendly, yet semantic configuration ?
How to ensure great auto-completion for ease of use ?
What needs to be done to have a proper Profiler ?
How to keep memory efficiency by leveraging the HttpClient ?
How to make the asynchrone generation easy ?

Come and discover how generating PDF's is now as easy as using twig !

Its loose type system and implicit type casts make PHP a perfect programming language for beginners. However, if we rely on those features heavily, we will eventually end up with a codebase that is hard to control and maintain. In this session, Alexander will open up his toolbox and show how a stricter way of programming PHP applications helps him to not lose pace when applying changes to PHP applications.

In our project, we had a couple of hundred scheduled jobs. Recently, we've successfully migrated the project from Cron to Symfony Scheduler. It was a long way and I would like to share our experience:

- How to do it smoothly?
- What advantages and disadvantages can we get from migration from Cron to Scheduler?
- What problems face we face during the migration?

When you've been tasked with creating an HTTP API, the fundamental decision you need to make is which architecture to choose. Should your API be RESTful? What about GraphQL? or RPC? In this session, I'll explain the choices and how each works. We'll then look at their strengths and weaknesses in order to help guide your decision. By the end of this talk, you'll be well-placed to choose the right API architecture for your project.

Static analysis tools like PHPStan have become essential for PHP developers, and Symfony projects can greatly benefit from custom rules tailored to their specific needs. In this talk, I will guide Symfony developers through the process of writing custom PHPStan rules to enforce project-specific standards and catch domain-specific bugs, and freeing up valuable time by automating repetitive code review tasks.

Let's delve into the intricacies of Symfony Notifier component: you'll learn all about its inner workings, from channels to transports and configuration.
We'll take advantage of this journey to develop a new feature of the component: sending postal mails.

Join us for an insightful session on more sustainable and ethical tech practices. This conference will cover the essentials of Green IT, showing you how to minimize environmental impact through optimized development processes. You’ll also learn about the importance of accessibility, ensuring that your web applications are inclusive and meet accessibility standards. Additionally, the session will delve into data privacy, providing practical advice on managing data protection in your projects. Gain valuable knowledge and tools to integrate sustainability into your Symfony applications and contribute to a more responsible tech ecosystem.

Have you ever considered what would happen when a popular open source package is abandoned?
Now, what about when that package is one of your essential dependencies?

This scenario is not some abstract scenario for a far away future. Projects get abandoned every day and your dependency might be next... But you can help!
Come & listen to some tales of an accidental maintainer and learn about what you can do to help try and prevent these situations from getting out of hand.

Creating an unforgettable user experience in searchandising is a challenge for both developers and business professionals.

Enter Gally, our open-source searchandising solution, designed to meet the ecosystem's technical and functional needs with excellence.

Join us for an engaging talk where we unveil our journey in crafting Gally.

Discover how Gally harnesses the power of Symfony and API Platform to offer seamless extensibility for developers while boosting ease of use and revenue for businesses.

What started out as a sweet PEAR is now a sour PECL, and after many years of dealing with brined cucumbers it’s time to dish out some sweet new tools. Join us for a trip down memory lane as we take a look at the acquired taste of PHP extensions and their challenges from writing and publishing them to finally handling the installation procedure you are all too familiar with. The talk will give you an insight into an effort by the PHP foundation to bake a new PHP Installer for Extensions and how it will solve some of the challenges of dealing with PHP extensions.

Ever wondered what happens under the hood when you run a Composer update or why Composer 2 got so much faster? Learn about some of its inner workings, some lesser known parts and why they may be useful to you, as well as upcoming features and future plans.

Join Thibault Milan as he explores the transformative power of AI in web development. Discover how tools like GitHub Copilot, Tabnine, Perplexity, and Azure OpenAI are revolutionizing his workflow, enabling faster ideation and seamless entry into new tech areas. Thibault will share insights on integrating AI to improve coding practices, overcome technical limitations, and venture into uncharted territory.

This talk will inspire every developer to view AI as a complement to their skills, not a competitor, preparing them for a future where AI tools are indispensable partners in innovation.

Communication is key but challenging for developers, especially when working with people using different programming languages. Front-end developers extensively use Component Architecture, as it is implemented in all major JavaScript frameworks. Let’s explore what Component Architecture is and how to implement it in a real Symfony application. This approach will enable your team to work efficiently on the same codebase, fostering better communication and collaboration by speaking the same technical language.

In this forward-thinking talk, I'll take you on a journey through the integration of AI in Symfony projects. Drawing from our real-world experiences, I'll demonstrate how to build adaptable AI systems that can withstand the ever-shifting landscape of AI technologies and regulations. You'll learn our strategies for creating a provider-agnostic AI architecture, ensuring your Symfony applications remain flexible amidst changing requirements and GDPR considerations. Join me to discover how to future-proof your projects and avoid vendor lock-in while harnessing the power of AI in your Symfony ecosystem.

When you're faced with auditing an application or a set of applications, it's easy to get lost and forget the big picture. Let's discuss which tools are best suitable for every part of the audit, which aspects of the stack should be audited and how to proceed. Join me in finding out which traps to avoid and how to best carry out your next audit.

The Security component has changed a lot in the past few years.
From Authentication Listeners to Guard and finally the Authenticator Manager system, Symfony now has the most robust infrastructure ever to support most if not all modern, industry-standard Security protocols.

The community started building on these new foundations by introducing an AccessTokenAuthenticator and kept improving it since then, notably through adding more token handlers for well-known authentication protocols.
That's pretty cool already, but what should we expect next? How far will we take it?

In this talk, I'm going to put my Security maintainer hat on to answer these questions and share some insights about what's going on in this critical part of our beloved framework.