SymfonyOnline January 2024

January 18 – 19, 2024

Watch the talks in video

If you attended this conference, watch the replay of the talks.
Otherwise, you can Buy a ticket to replay the videos.

Revolutionizing Command-Line Interfaces with Symfony's New Terminal Component

Fabien Potencier

Fabien Potencier's keynote at SymfonyCon Brussels introduces the groundbreaking Terminal component for Symfony, a major iteration built on the existing console component. This new addition, set for a multi-year development, aims to enhance Symfony's command-line interface capabilities significantly. It will include features like improved color handling, intuitive styling, and widget support for dynamic and interactive command-line applications. Fabien's presentation covers the component's architecture, showcasing how it can bring HTML and CSS-like styling to the terminal, along with support for interactivity through mouse and keyboard inputs. The Terminal component represents a significant leap in developing user-friendly and highly functional CLI applications in Symfony.

Stop firefighting with Blackfire!

Thomas di Luccio

Are you stuck in an endless cycle of hotfixes? It's time to stop reacting to issues when they appear and start proactively enhancing your applications.

Explore implementing Blackfire, a robust observability solution, moving from reactive emergency fixes to strategic, data-driven, and long-term improvement at every stage of your development and deployment lifecycles.

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.

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.

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.

Caught in a Web: Untangling Graph Structures

Christian Rades

Linked data is everywhere: Object graphs, nested Documents, git commits. The structure of those links is often just as valuable as the data itself. This is why knowing how to store and manage those links opens opportunities. This talk will show you how to represent this data in PHP and how to use common algorithms to utilize the structure.

You will hear how we tamed nested documents to order their insertion into a relational database and show you all the places where these kinds of links appear.

We will close out with a little peek at how applying this knowledge can even help you guide the development of your code base.

This will enable you to spot the links in your data and apply well-known methods to get the most out of it.

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.

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.

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

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.

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.

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.

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.

Testing with HttpClient, the automatic way

Gary PEGEOT

Writing tests for a service that uses 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!

In this talk, we will discover ways to greatly improve DX when testing code that interacts with Symfony's HttpClient: from manually defining responses to a fully automated workflow, and a sneak peak at a brand new way to record and replay your responses.

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.

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.

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.

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.

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.

Remote Work: Past, Present, and Future?

Fred Plais , Caroline Leroy

Fred Plais and Caroline Leroy from Platform.sh discuss the evolution and impact of remote work in the tech industry. Emphasizing their experience since 2015, they explore remote work's challenges, advantages, and its role in shaping company culture and productivity. With insights from the Symfony community and Platform.sh's own journey, the talk addresses misconceptions about remote work, emphasizing its necessity for attracting diverse talent and fostering a flexible, inclusive work environment. Despite initial resistance and current debates, they predict a strong future for remote and hybrid work models, advocating a team-driven approach for determining the best working conditions.

Supporting the Future of PHP: The Role of Symfony and PHP Foundation

Nicolas Grekas

This presentation focuses on the development and future of PHP, emphasizing the PHP Foundation's role in sustaining and advancing the language. It highlights the minimal contribution to PHP's development despite its widespread usage and the pivotal role of the PHP Foundation in addressing this gap. The foundation, supported by major PHP-based projects and companies, aims to improve PHP for end-users, ensure high-quality maintenance, and promote PHP's modern image. The talk discusses the foundation's achievements, challenges, and ongoing projects like lazy objects and property hooks, underscoring the importance of community and financial support in shaping PHP's future.

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!

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 😁

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!

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.

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.

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.

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?

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!

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

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?

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!

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.

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.

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.

Sponsors

Diamond Sponsors

Gold Sponsors

Did you miss SymfonyOnline January 2024?

Join us at an upcoming conference!

SymfonyCon Vienna 2024

Vienna / Austria

December 5 – 6, 2024

Talks are in English

SymfonyOnline January 2025

Online

January 16 – 17, 2025

Talks are in English

SymfonyLive Paris 2025

Paris / France

March 27 – 28, 2025

Talks are in French