Schedule is not complete yet

We're still selecting talks and speakers for SymfonyWorld Online 2020. The following list only shows the already confirmed talks. Come back in a few days to see the full schedule.

Get Social! Implementing Social Login in your Symfony Project

Pauline Vos

You build a beautiful application, only to have users drop off at the registration step. It's a challenge many of us have struggled with. Social login can lower the bar for users, and increase conversion in your on-boarding funnel.

Implementing it can be very straightforward, but what happens when you need something more specific for your application? And how do you make sure the entire round-trip is tested properly? We'll discover all the pitfalls and challenges and how to solve them in this talk.

Streaming: an alternative to CRUD & batch processing

Samuel ROZE

If a product or a company grows after its early stage, it’s not rare that there will be multiple systems or “services” communicating to each other. The two most common ways are by using APIs or batch processing.

In this talk, I will show you another way, message streaming. This less known technique has great maintenance and decoupling properties given that you understand its ordering and idempotence requirements, which we will discuss. We will also see how partitioning allows us to scale the streams in separate segments, while maintaining the previous requirements. We will wrap up by a summary of things to watch out for if you take this route after discovering why it might be very beneficial to your project(s).

Password Hashing and You

Chris Holland

At one point or another, odds are strong that users will need to create an account on our site, and we will likely be asking of them to create a password.

The question then becomes: How should we store the password?

While this is something we typically "let frameworks worry about", it is important to understand what the stakes are, current and emerging threats, as well as current best practices of this field.

Serializer Demystified

Denis Brumann

The Serializer is an essential tool when building APIs with Symfony. Knowing it in more detail can save you a lot of time when you want to customize how your data is handled. In this talk we will look at how the Symfony Serializer works by default by having a deeper look at the provided Normalizers and then we will look at some use cases for customizing both how data is serialized and deserialized.

The absolute beginner's guide to Domain Driven Design with Symfony

Neal Brooks

DDD is one of the most effective ways to address business problems, but it can be overwhelming to get started with. Even armed with the theory, beginning the journey is mysterious and finding answers to specific implementation details can be tough and scary.

In this talk we'll demystify the terminology and work out the most important aspects of DDD you'll need to get you going. Then, by exploring and implementing a sample business domain, we'll discover such things as:
- How DDD entities differ from Doctrine entities
- What an aggregate root actually is
- How to organise your code
- How to define a bounded context
- How a domain service differs from an application service

Finally, we'll wire it all together with Symfony 5. So if you've been wanting to get started with DDD for a while but never knew how or where to start then this talk is for you.

Why 0.1 + 0.2 != 0.3, or the mysterious world of floating-point numbers.

Benoit Jacquemont

Yes, running the above expression in PHP, and in a lot of other languages, will confirm that 0.1 + 0.2 does not equal to 0.3.

But this weird behavior is explainable and even justified.

Floating point numbers can open you up a completely new universe.
Provided of course that they are properly used.

This talk will go through a bit of theory, and a lot of concrete examples.

From the Gulf War to the Quake graphics engine, via the Ariane 5 space rocket, we will see the benefits and the potential dangers of using floating-point numbers.

From these examples, we will extract some lessons we can translate into our day to day development practices.

And finally, the talk will cover when to use floating-point numbers, and when to avoid them, like when managing prices or billing, and what are the alternatives in those cases.

Decoupling an application with Symfony Messenger

David Buchmann

Quick response times are crucial. Time consuming tasks triggered in web requests should be executed asynchronously, if at all possible. In this talk I will give a short overview of what message queues are and then show a case study how we split up an application into smaller services and how we use message queues to coordinate the services.

Dropping ACID: Schema design for e-commerce

Andreas Braun

When designing a schema for e-commerce applications, we have to keep certain things in mind: data retention rules require duplicating large chunks of data, leading to complex schemas in any relational database. Modern database systems can help us solve this problem, but we seldom use their features when designing schemas. In this talk, we will take a look at some strategies on how to design more efficient schemas for certain database systems, and how to effectively drop ACID at work.

PHP + Minecraft

Thomas Berends

Minecraft is extremely popular, but what happens when we combine it with PHP & Symfony? This talk is an adventure in using PHP for things outside of your comfort zone.

At the start, it seems that these do not work together at all. By reading files we can get information about what happens in Minecraft, from logs to the complete world. However, it gets truly interesting when we can change things in the world with PHP. This opens a lot of possibilities we will explore in this talk.

This talk requires no knowledge of Minecraft.

Standalone Dependency Injection

Alexander M. Turek

Symfony's DependencyInjection component is the glue that holds a Symfony application together. But what if we were to build a small console tool without the full-stack framework? Let's see, how we can use the component standalone as a foundation for an extensible application.

Elasticsearch with Symfony, from development to production

Damien Alexandre

Search is at the core of many standard application, but building and deploying a full-text search engine is not trivial. One of your options is to implement Elasticsearch and in this talk I will show you the path, from development to production. We will also leverage the new Symfony HttpClient to communicate with the cluster more efficiently!

Symfony meets Cypress - E2E testing for symfony developers

Ramona Schwering

When it comes to UI testing, some developers tend to be reluctant a lot. Are those tests slow, flaky, hard to write and maintain? (or Cypress for short) is currently getting a lot of attention when it comes to end-to-end testing. Especially in JavaScript environments seems to be slowly gaining acceptance. However, it plays to its strengths in Symfony applications as well: It does a lot of things right and is preferable to selenium-based approaches in my opinion.

In my session, I want to introduce Cypress to you and explore its possibilities by writing first tests for the SymfonyCon website - so that we can overcome those concerns together.

What's new in API Platform?

Kévin Dunglas

API Platform is a popular framework to build API-driven projects. The server component is built on top of Symfony. It enables to create modern, extensible and secure web APIs very easily: design the public data model, and that's all, you get a fully-featured API!
But API Platform also provides awesome client-side components (written in JS) working with the server component, and with any other modern REST API! These components include a smart admin builder and client generators supporting React, Vue, React Native, Next, Quasar and Vuetify! Last but not least, API Platform comes with the Docker images and the Kubernetes chart you'll need to deploy in production, in seconds.
Since its introduction during SymfonyLive Paris 2015, API Platform evolved a lot! It is now recognized as the easiest and most powerful set of tools to build and use new web APIs, even outside of the PHP world. During this talk, will discover the new best practices and the unknown gems provided by the framework.

Composer 2

Nils Adermann

Composer has permanently altered the way of PHP development over the last decade. The tool's second major version comes with new features and many improvements to functionality and performance. The most important changes will be highlighted in this talk. We'll show you what you need to know to upgrade your own projects and explain some of the background which lead to version 2.

Lock & Semaphore: The gatekeepers of your resources


Released with Symfony 3.4, the Lock component allows you to limit concurrent access to shared resources. 3 years later, its little brother, the Semaphore component completes the range of tools at our disposal.

Well beyond the classic flock() or sem_acquire(), these components enable us to cover more complex use-cases such as maintaining a lock on several pages or integrating into a distributed and high availability infrastructure.

In this talk, through business examples, I'll show you how those components work. And we will see the possibilities they offer us as well as their limits.

Better Console Applications

Christopher Hertel

Console applications - whether part of a larger (Symfony-)application or standalone-tool - usually are the bash-script of PHP developers. Thereby one often leaves the path of clean code and hacks a very pragmatic solution. Despite the fact that a lot of these fast solutions remain in project and need to be maintained for longer. What to reason about while developing a console application and which simple tricks help to clean up your code, is shown by examples in this talk. How do I decouple my code from CLI runtime, how do I optimize long running processes and so on.