Schedule

In software architecture, it is always about finding the best solution for your use case and your application in your specific context. Based on that, you have the challenge to find the right balance between flexibility and simplicity. We often must decide between a monolithic system and a microservice architecture. For a long time, the monolithic architecture has been the way to go. Then, microservices came up and most architectures followed way. Today I would like to present an architecture that attempts to combine the advantages of both paradigms.

Using a concrete example project, I will discuss the advantages and challenges of a modular architecture. I will present a possible approach to the appropriate structuring of Symfony applications using modulithic architecture and show how it can help to map modern software development requirements.

Webhooks provide a convenient solution for businesses to notify third parties of events, but their integration can be complex.

The purpose of this talk is to explore the fundamentals of webhooks and present practical strategies for their effective management. By utilizing API Platform alongside Symfony's Webhook component, we aim to demonstrate how to seamlessly implement and optimize webhook handling for enhanced performance and integration.

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.

In an era where external APIs are becoming increasingly prevalent, our tests find themselves dependent on these APIs.

The initial thought for our tests might be to create mocks to simulate these APIs, but this can quickly become tedious and challenging to maintain.

In this conference, we will explore how to test an external API while staying closely aligned with its contract and without relying on any mocks.

Writing and reviewing integration and functional tests with Symfony can be clunky. Using the traditional recommendations, they can be verbose, hard to follow, and require outside state. I think tests should be concise, read like a story, and not require some kind of known initial state (i.e. pre-loaded database fixtures). I'd like to put a spotlight on several 3rd party bundles (some maintained by me) and show how they can be used to improve your testing experience. I'll demonstrate how easy and fun creating a new feature for your app can be using these bundles and TDD.

Finally, I'll share my ideas for a "Symfony Testing Initiative" that I'm spearheading to bring these excellent testing tools into Symfony core (as both code and official docs/best practices).

What if there was a secret ingredient to enhance the user experience of your project without leaving the comfort of PHP/Symfony? For prototyping, or even developing a front-end... in PHP?


Join us on a journey to explore LiveComponent during this session of Symfony Online June 2024!


# Objective

Embark on a L-I-V-E adventure where we'll attempt to answer the following questions:

* LiveComponent: a good choice for your project?
* LiveComponent: suited for you and your teams?
* LiveComponent: for today and for tomorrow?


# Program

L - Live: vibrant web applications
I - Integrated: at the heart of Symfony
V - Versatile: project catalyst
E - Experience: UX and DX improvements


# Why Attend?

If you're interested in modern web development techniques, if you want to improve your application's user experience, or if you're curious to discover the new features of Symfony UX, this session is for you!

Using Git magic for the Symfony mono-repo

In this talk I will explain how we started with a poorly tested legacy project with Symfony 3.4 and PHP 7.2 and we took it all the way up to Symfony 7 and PHP 8.3. We will talk about all the steps that we took, all the tools that we used, the difficulties that we found along the way and the benefits that we received. The talk will include a lot of samples of the changes that we had to apply at all levels. If we could do it, you can (and should) do it!!

No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.

In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.

We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.

In this presentation, we will explore the reasons for using Symfony UX and how to implement it in a practical application. To begin, we'll delve into the fundamental rules and principles that Symfony UX adheres to. We will then take a detailed look at its component architecture, including Stimulus and Turbo. Throughout this discussion, you will see the positive impact that these technologies can have on your team.

We recently introduced the AssetMapper component and Symfony UX to make the most of the web platform and reduce the amount of JavaScript code to the absolute minimum.

This “radically simple” approach is generally the most efficient and should be the go-to method for most new Symfony applications.

However, API-based, JavaScript-heavy applications are still inevitable or more straightforward than the alternatives for many other use cases:

* building rich applications that leverage the device’s hardware capabilities (3D, GPS, E2E encryption, Bluetooth, NFC…) and work offline (service workers)
* building mobile applications distributed via the App Store and Google Play (React Native, Ionic)
* building “native” desktop applications (Tauri, Electron…)
* building advanced editors à la Google Docs
* creating API-first systems
* …

For these kinds of applications, you need JavaScript (or TypeScript) applications, but the Symfony ecosystem is still relevant and can help: through the API Platform project, it provides all the tools you need to design and develop the web API that will be used in PHP, then scaffold your heavy JS applications by reading machine-readable API documentation.

Symfony now has two paths for front-end application development: let’s find out when to use Symfony UX and when to take advantage of API Platform’s JavaScript tools!

Let's dive into the history of the Serializer, one of Symfony's core component. Many improvements have been made over the years, but what about today?
How can we take serialization one step further and combine flexibility and performance?