SymfonyOnline June 2024

Using Git magic for the Symfony mono-repo (Fabien Potencier)

Using Git magic for the Symfony mono-repo

Carry out the best audit for your client (Marie Minasyan)

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.

LIVE (Component) Experience (Simon André)

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!

The big upgrade. All the way up to Symfony 7 and PHP 8.3 (Carlos Granados)

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!!

How to Test an External API with 0 Mocks? (Ezzine Imen)

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.

Practical insight into modulithic architecture (Max Beckers)

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.

Designing Security-First Symfony Apps (Stiven Llupa)

Start exploring secure software development with Stiven Llupa. Learn how you can integrate security into development and simplify the process with Symfony. Symfony components, tools like Composer, libraries like Doctrine and Monolog, help mitigate security risks, ensuring more secure applications. Join us to hear more on what is secure software development and practical insights from a real-world project. Enhance your Symfony projects without compromising security -- don't miss out!

Crafting Elegant Symfony Tests (Kevin Bond)

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).

Revisiting lazy objects in PHP and Symfony (Nicolas Grekas)

Lazy objects are essential for non-trivial PHP applications. Fortunately, they are also as transparent as possible, so you are likely using them without even knowing it. This talk aims to explain what they are and how they work. Let's dive into some intricacies of PHP together.

Efficient Webhook Management with API Platform and Symfony's Webhook component (Allison Guilhem)

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.

Front-end application development, Symfony-style(s) (Kévin Dunglas)

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!

Using container's features to manage complexity (Viktor Pikaev)

Symfony gives us a lot of tools that help to develop complex applications. One of them is a container which provides much more than a simple dependency injection. It's a flexible and extensible library, and we can use its features to decrease the complexity of our applications. In this talk, I would like to show you how to use container's advanced features and modern PHP functionality to manage the complexity of the system.

Need for Speed: Removing speed bumps from your Symfony projects (Łukasz Chruściel)

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.

Serialization and performance (Baptiste Leduc, Mathias Arlaud)

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?

Leveraging Symfony UX in a Real Application (Matheo Daninos)

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.