SymfonyCon Brussels 2023

Keynote (Fabien Potencier)

Keynote

Simplified Processes With Symfony Workflow (Bruno Henrique De Souza)

The Symfony Workflow Component is a feature-rich tool that empowers developers to model, manage, and execute workflows seamlessly. In this talk, we explore its key features and real-world applications. After a quick introduction, we will cover the topics of workflow model building, managing workflow instances, etc. I will base my example on practical use cases in the Smartbox business using a DDD structure, and best practices for optimizing performance and error handling in large-scale workflows.

Domain-Driven Design: The Basics (Stefan Koopmanschap)

So you’ve heard people talk about Domain-Driven Design. But what is it? What is the blue book? And what is the red book? How can it be applied to your project? During this session you’ll learn more about the basics of Domain-Driven Design.

Upsun: From zero to scaling hero (Guillaume MOIGNEU)

Deploying an app for the first time is always daunting. It does not need to be. We will setup a quick ChatGPT client based on a Symfony REST API and a React frontend. These app will be deployed to Upsun where we will analyze some performance bottlenecks and scale the infrastructure appropriately based on these findings.

Multi-tenant applications using Symfony, for real? (Tugdual Saunier)

Over the last decades, with more development moving toward the web and because of increasing privacy concerns and regulations, data isolation as a requirement became more prevalent. The concept behind multi-tenancy is to isolate different entities (customers, users, institutions, etc.) data while using, maintaining and usually deploying a single codebase. Seems simple on paper, right? Or does it? The multi-tenancy topic is often perceived as complex and the implementation job feared, without mentioning the maintenance burden. Is it with due reason? Or is it some part of a myth because, historically, multi-tenancy used to be an "Enterprise"-grade software exclusivity? Let's check! After a brief overview of the concept and the general challenges induced by multi-tenancy, we will review the most common ways teams are implementing multi-tenancy. We will then discover why PHP is a good candidate for multi-tenant software despite the general opinion. Finally, let's explore how one can leverage Symfony features to ease their job implementing and maintaining multi-tenant stacks. Who knows? We might even find some tricks to implement hybrid solutions or some alternative architectures along the way 😁

I did it ! I broke production ! (Sofia Lescano)

About to finish my first year in my company, I caused not one but two incidents in production in one hour! Despite the tense moment, it was a huge learning. No one ran with their arms in the air, shouting at each other, nor began to look for culprits. Conversely, a close-knit team that helps each other reestablished the production as quickly as possible by collectively acknowledging the error made. How do we manage a production incident with peace of mind? - an upstream quality process (code review, sandbox environment, functional review ...) - a process for detecting and reporting incidents - clear roles and responsabilities on incident management - a post-mortem and concrete actions to avoid a repeating similar incident In this conference I will explain how to reduce and improve the management of your incidents and you will leave with the keys to apply this in your teams.

Expression Language in Symfony: Beyond the Framework (Rémi JANOT)

Expression Language (EL) is a powerful tool that can be used to dynamically evaluate expressions in Symfony applications. However, EL is often overlooked for use in the business domain. In this talk, we will explore how EL can be used to: Increase flexibility and extensibility in your applications Avoid the need to redeploy your application every time you need to make a change Implement complex business logic in a clear and concise way We will also discuss some of the best practices for using EL in the business domain. Whether you are a Symfony developer who is looking to learn more about EL, or a business analyst who is looking for a way to implement complex business logic in your applications, this talk is for you. Here are some specific examples of how EL can be used in the business domain: - Calculating discounts based on customer loyalty - Determining the eligibility for a promotion - Validating user input - Generating dynamic content

Get a grip on your project's supply chain (Nils Adermann)

Everyone has heard of supply chains at this point, but what exactly does that mean for a Symfony project? Learn more about software supply chains, how tools like Composer and services like CI or Private Packagist come into it and which role PHP dependencies play. This talk will present concrete steps you can take to identify your dependencies and give advice on measures you can put into place to better manage and protect how your application is assembled.

Your Weakness is Your Superpower (Mary Thomas)

Too often, we are told to highlight our weaknesses as a means for growth. From job interviews, to performance reviews, to our own self-reflection, we shine the light on what we do poorly. Building our careers isn't about doing everything well - instead, it's about doing what we already know we're good at to the best of our ability, and using the knowledge of our weakness to employ our strengths. This session would show why identifying and leaning into our strengths becomes our weakness Superpower.

PHPUnit 10 for Symfony Developers (Sebastian Bergmann)

Version 10 is probably the biggest update so far for PHPUnit. Almost all internals of PHP's most widely used testing framework and test runner have undergone long overdue changes to improve the developer experience of those who work on PHPUnit. This presentation highlights the improvements that were made for those that write and run tests with PHPUnit every day and shows why some parts of Symfony's PHPUnit Bridge might be removed soon. Join Sebastian Bergmann, creator and maintainer of PHPUnit, to learn everything you need to know about PHPUnit 10. You will experience new features, big and small, in action and see how they can support you to effectively and efficiently test your software.

Kaizen-Inspired DevOps (Branislav Bujisic)

High-performing teams sustain their momentum through the synergy of skilled individuals, efficient processes, and adaptable practices. The primary objective of performance tuning is to minimize inefficiencies and bolster a team's ability to withstand external disruptions. This session will delve into a diverse array of techniques and processes aimed at reducing wastage and enhancing resilience. Our journey will commence with an exploration of the contemporary skill set essential for constructing swift and anti-fragile systems. Subsequently, we will delve into the development and management methodologies that underpin both the team and product in the face of a dynamic environment. Finally, we will investigate the tools available to support these methodologies effectively. This session is designed primarily for engineering managers, particularly those with technical backgrounds. However, it also offers valuable insights to anyone with an interest in DevOps, team scaling, and agile methodologies.

Strings usage : so many tools are already in your hands! (Marion Hurteau)

Playing with strings is probably the first thing you did when becoming a developer. But do you know what is hidden behind these graphemes on your screen? What does “grapheme” even mean, you might ask! If you’re a bit confused about concepts like charsets, collations, or Unicode – and don’t worry, I was too – then this talk is for you! From theory to practice, we’ll then dive into the String component, which relies on those concepts, and see it in action with concrete examples!

Using symfony/messenger standalone (Susanne Moog)

In this talk, we will explore the essential steps for leveraging Symfony Messenger's capabilities within an application not based on the full symfony framework. As an example, we take a look at how the symfony/messenger component was integrated into TYPO3, enabling efficient asynchronous communication and message handling.

Static Analysis Crash Course for Framework Developers (Ondřej Mirtes)

In recent years, static analysis tools like PHPStan have become super popular in the PHP world. These tools do something cool: they can spot all sorts of mistakes in your code before you even run it. Usually, people try these tools on their own code. But if you're the person behind a framework or library that others use, guess what? They're probably using these tools too. So, the code people write using your stuff also needs to pass these checks. This creates an extra thing you need to worry about. You've got to make sure your framework or library works nicely with these tools. And if you're smart about it, you can even help guide other developers to use your code the right way. In my talk I'll take you through three important steps: 1) Laying the Foundation: I'll start by covering the essentials. This involves establishing a basic standard, ensuring that users achieve a green build when working with your framework. 2) Empowering with Strong Types: The second part focuses on the potential of strong types. We'll explore how they can effectively steer users towards correct usage. 3) Going Advanced with Custom Rules: Lastly, I'll teach you how to do something advanced but useful. You can create special checks for your framework using PHPStan. I'll give you examples from big frameworks like Symfony and Doctrine so you can see how it works. By the end you'll have the knowledge you need to make sure your framework works great, and people love using it.

Balancing Act: The Product Trio (Shawna Spoor, Sukhman Virk)

Product, Engineering, and Design need to work together in a healthy and positive way to ensure smooth, quality feature development. Often the elephant in the room is, who is in charge? We discuss the answer to this question: surprise, it's not one single person or group. Then we look at how to use this answer to your development cycles advantage and how it can open doors to happy and productive teams, and facilitate rapid feature development. We'll dive into examples of how this worked well during the development of Upsun and when it didn't work so well.

Symfony Apps as Standalone Binaries (Kévin Dunglas)

Distributing Symfony applications is quite complicated. To run a Symfony project in production, a web server, a PHP executor, and - usually - a database server need to be installed. Their versions and configurations must be compatible and the app. Because PHP is an interpreted language, the application source code must also be available. Composer dependencies as well... and things are even more difficult if some of them are private. Of course, these days, containers can help. But what if we could make it even simpler: a single distributable binary that's self-executing? Download a single file, give it the execution bit, and type "./my-app run": boom! Your Symfony application is up and running, served over HTTP/3 with a valid TLS certificate! Thanks to the latest new features of FrankenPHP, the dream is now a reality! Let's discover how to ship Symfony applications as standalone binaries, web server, PHP and database system included!

Taming container environment maintenance: let's go Nix-ing! (Jérôme Vieilledent)

Producing and happily maintaining container images: :smiley: :white_check_mark: Including many up-to-date packages: :muscle: While still delivering older runtimes: :melting_face: :exploding_head: Dependency hell is this annoying guest who’s ruining your party and making the situation uncomfortable. You didn’t realize they were invited, but now they’re here breaking everything. Would it be possible to generate and maintain sane up-to-date environments, with packages having eerie dependencies? The answer is YES, and you don’t have to read the Necronomicon to make that happen. It’s called Nix, and it ain't dark magic… So, are you ready to Nix?

Do you really know JWT? (Karim Pinchon)

Over the past few years, many of us have seen or used special tokens: JSON Web Tokens, or JWTs. This token standard is a very practical way of transmitting information reliably. These tokens are often used for authentication with web services, microservices or SSO as part of OpenID Connect. In addition, we see a lot of JWS (signed tokens), but that's not the only implementation out there. In fact, the JWT specification is much broader than you might think. Here's a look at some of the lesser-known aspects of JWT.

Symfony, PHP and its Foundation (Nicolas Grekas)

The PHP Foundation aims to sustain and grow PHP's development, ensuring its longevity and relevance in a rapidly evolving tech landscape. It has been established to foster community contributions, support PHP core developers, and help steer the strategic direction of the language. Attendees will gain insights into the symbiotic relationship between Symfony and PHP, and understand the critical role of the PHP Foundation in shaping the future of this enduring language.

A Memorable Game UX with LiveComponents (Simon André)

Symfony UX empowers developers to create rich, dynamic web interfaces that bridge the gap between backend logic and a memorable user experience. In this session, we’ll experiment with LiveComponents to assemble, step by step, a complete gaming experience using PHP (and a couple of CSS tricks). Spoiler Alert: we’ll do it all without writing a single line of JavaScript.

Q&A with the Core Team ()

Core team Q&A

Keynote: Is Remote the past or the future of work? (Fred Plais, Caroline Leroy)

After the Covid surge, has remote work recently gotten unpopular in 2023? Many large tech companies have now turned their backs on remote work. Remote work would decrease productivity, hurt the company culture, generate silos... leading to reestablishing back to the office policies in many tech companies. How much of this stands and how much can be mitigated? This session will explore good practices from the field and actionable testimonials that can help make remote work fine both for employers and employees.

TDD Styles: London VS Chicago (Diego Aguiar)

Did you know that there are different TDD styles? The most famous ones are London and Chicago styles. ​ The London style comes from the mockist school, and it's an "outside-in" approach. It starts from the outside of the application (APIs/Controllers) and works its way down to the domain layer. ​ The Chicago style comes from the classicist school, and it's an "inside-out" approach. It starts from the domain layer and works out towards the APIs/Controllers. ​ In this talk, we'll discover what makes those styles unique, their key differences, and their advantages and disadvantages. ​ Don't miss it out and get your TDD expertise to the next level!

Need to search through your data? Heard about Meilisearch? (Guillaume Loulier)

In the current world that we lives in, data is everything, from « big data » to health, from cars to planes and from cities to companies, our data have becomes one of the most important part of our daily life and for us, as developers, part of your daily job. If you’ve already played with huge volumes of data, you might have heard of Elasticsearch and many others, each one built with pros and cons and with specific goals in mind, thing is, what if we can continue to play with our data but in a more « memory efficient » and faster approach? 

 What if we can ingest, search, filter and return data without worrying about using Java, consuming a lot of resources and/or booting a heavy stack? 

 Well, let me introduce MeiliSearch, a Rust-based search engine along with its integration in PHP / Symfony, in this talk, we’ll discuss what is MeiliSearch, how to use it and how to search through our data to extract the most of it, ready? Let’s search!

Refactoring monolith to multi-app (Florent HUCK)

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!

It's a (testing) trap! (Ramona Schwering)

“It’s a trap” - a call or feeling we all might be familiar with, not only when it comes to Star Wars. It signalizes a sudden moment of noticing imminent danger. This situation is an excellent allegory for an unpleasant realization in testing. Imagine having the best intentions regarding testing but still ending up with tests failing to deliver any value. Tests that feel like a pain to deal with? When writing tests, there are lots of pitfalls on the way. In sum, they can lead to lousy maintainability, slow execution time, and - in the worst-case - tests you cannot trust. But it doesn’t have to be that way. In this session, I will talk about developers’ common mistakes (including mine) in tests, at least from my experience. And, of course, how to avoid them using best practices. Testing doesn’t need to be painful, after all.

Regex: demystifying the hieroglyphics (Marine Gandy)

While regular expressions can certainly look like hieroglyphics, once you understand the basics, you can unlock massive amounts of power in your searches and work. You're working with some data and find yourself needing to find a specific piece of information, but your searches keep matching things that you don’t want. While basic searches are fine for some things, every once in a while you need something more powerful. Enter regular expressions (also referred to as "regex"). BUT WAIT! Before you scroll to the next session description: did you know that this powerful searching capability is available in things like Word and Excel, as well as Google Search Console and Google Analytics? And not only can you use it to search for information, you can also use it to transform information! In this session, we'll jump into a brief history of regex, discuss pattern matching, and dive into the fundamentals of how we can use regex to surface the data we've been searching for in powerful ways

A serverless Symfony playground (Antoine Bluchet)

I bet you already used 3v4l.org or similar websites to run PHP code to find out whether array_merge is slow or not (it's slow). If you take a look at how these website works they usually use a PHP server behind the doors and transfer data between the browser and the server. The problem is that running PHP on the server just for testing purposes can quickly become expensive in terms of hosting... How about running PHP directly in the browser? In this talk, I'll introduce you to WebAssembly, a technology that enables programs to be compiled to run in browsers. Next, we'll discover how to compile PHP into WebAssembly. And finally, we'll see how to run Symfony or any other PHP project directly in the browser, without the need for a (PHP) server.

Github Actions 101: your 1st action (Paul Gilzow)

We all know we should be doing more automation of our software development lifecycle, but getting started can be challenging. Even if you have experience in continuous integration and continuous delivery (CI/CD) automation, learning a specific platform’s terminology and idiosyncrasies can be frustrating. This presentation is designed to provide an overview of GitHub Actions, a CI/CD platform that allows you to automate your build, test and deployment pipelines, and writing one’s first action, a reusable component that can automate repeatable tasks. We’ll start by going over key terms and concepts in the GitHub Actions platform, such as actions, workflows, events and jobs, and explain how they can be pieced together to build robust and dynamic automations. Then, we’ll dive into the process of building your first GitHub Action, walking through the steps of creating a new action, the types of actions you can create, defining inputs and outputs, and required properties. We’ll then work together to build an action that can be immediately used in your own workflows. Whether you’re a seasoned developer looking to move to GitHub Actions or a newcomer to automation looking to get started with your first CI/CD automation, this presentation will help jumpstart your journey.

How much database abstraction do I need? (Alexander M. Turek)

SQL databases are an important part of many web applications. But what's the best way to interact with such a database? Do I use hand-crafted SQL statements everywhere in order to always remain in control? Or do I use an ORM, so I don't need to repeat myself too often and to remain compatible to multiple SQL databases? We will take a deep dive into the Doctrine libraries ORM and DBAL as well as native PHP extensions and compare them with our use cases in mind.

From Chaos to Control: Exception Handling in Symfony (Anne-Julia Seitz)

Have you seen controllers grow with every exception that needs to be handled? Have you ever wondered where a particular exception is handled, or if you can be sure that all exceptions are handled so that the user always gets the correct response codes? Error handling gets little attention in the beginning, but needs to be addressed at some point. PHP development has become stricter over time, and we want to leverage this for robust error handling in Symfony applications. The presentation covers basic exception handling concepts while exploring best practices with Symfony's error handling components. Topics include custom exceptions, efficient logging, and error handling. The presentation will benefit both experienced and novice Symfony developers.

Symfony is RAD (Rick Kuipers)

What happens when you just ride the wave? How productive can we be when we smother our project in all that Symfony goodness? Let's explore some Rapid Application Development practices that Symfony has to offer. We'll acquire the mindset needed and get ourselves familiar with a Symfony setup by the book. We will develop an MVP using the MakerBundle and we'll close the gap towards an MLP using Symfony UX. Live demo included.

Task scheduling can be boring, but not with Symfony scheduler. (Allison Guilhem)

In the dynamic landscape of modern web application development, achieving accurate and timely task execution is pivotal for improving user experiences and optimizing backend processes. By enabling applications to run processes at optimal intervals, task scheduling reduces the need for manual intervention and promotes overall operational efficiency. We will explore the capabilities of the Symfony Scheduler through a concrete use case that focuses on creating and maintaining a recurring task that is constrained by a predetermined schedule until a particular event happens. In this talk, we'll see how the Symfony Scheduler would have effortlessly enhanced the implementation of iterative automation in our case using some useful concepts from Symfony Messenger. We'll also take the opportunity to look at how Symfony Scheduler would have benefited our application, and what issues it might have raised. Ready to be amazed by this captivating component? Ready to dive in?

BC ("Be careful") when dealing with BC ("Backwards compatibility")! (Konrad Oboza)

Maintaining compatibility promises is part of keeping healthy relationship with community and customers. As maintainers of a framework that builds upon Symfony, being in turn used by other developers, we have a taste of both worlds. We will explore different approaches, starting with semantic versioning and going through different libraries. We will go behind the reasons why certain choices are made, and what consequences they have to both developers and maintainers. We will also emphasize how those dilemmas affect our everyday planning and development. Finally, we will take a look at a particular case of performing major changes across entire codebase, by looking at a specific case that happened to our own product – a rebranding while maintaining compatibility. We will dive into specific solutions we came up with, and what challenges needed to be overcome – some of which proved to be a surprise. “How to enforce class residing under two namespaces?”, “does class_alias work as one would expect?”, “how would autoloading work in this scenario?” are, among others, questions we needed to answer and that would like to share answers to.

Testing with HttpClient, the automatic way (Gary PEGEOT)

Writing test for a service that use HttpClient is sometimes far from a walk in the park, especially if you do a lot of requests. Let's see if we can do something about it!

Why open source still matters - and now more than ever (Ben Marks, Niklas Dzösch)

While the economy gets tense, the management tends to ask why give software away for free. In this talk, Ben and Niklas from Shopware will give you their take on why open source is more than capable of driving as a business model and why it's essential not only in terms of business but also as a foundation of a healthy community.

How to use GPT with your Symfony app (Christopher Hertel)

With the release of ChatGPT, OpenAI has generated a lot of buzz around GPT and AI in general. For software architects and developers, this is not only a game changer when it comes to learning or debugging, but also introduces a new tool to embed into your system's architecture. In this talk, we will take a closer look at the basic concepts of GPT, the relevant models, and how you can effectively utilize them in your Symfony application.

Hands-on with LiveComponents, AssetMapper, Turbo & Stimulus (Ryan Weaver)

Symfony UX is celebrating its 3 (!) year anniversary! And a lot has changed. Gone are the days of needing a big build system... or a ton of complex custom JavaScript to get that single-page-app experience. LAST stack - LiveComponents, AssetMapper, Stimulus and Turbo - offers an alternative that makes writing frontend code fun & productive again. In this talk, we'll walk through the experience of building a modern web app with LAST stack. We'll see the latest changes to AssetMapper in 6.4 and see a bunch of real-world examples: building dynamic forms with zero JavaScript, modals, dynamic tables and more. Most importantly: we'll do this fast and *love* the experience.