PHP is nothing like compiled languages. If you make a mistake, the program will crash when the line of code with the mistake is executed. When testing a PHP application, whether manually or automatically, developers spend a lot of their time discovering mistakes that wouldn’t even compile in other languages, leaving less time for testing actual business logic.
PHPStan is a popular static analyser focused on finding bugs in your code. By leveraging the strength of PHP type system further enhanced in PHPStan itself, developers can create robust applications and discover bugs early in the development process. The aid the tool provides during refactoring is also indispensable.
In this workshop, the attendees will learn how to install, configure and run PHPStan, and also receive tips how to write code so that PHPStan can be as powerful as possible. They will also be able to write their own PHPStan rules and extensions.

Imagine building an application without having to mess with a Web Browser, a REST client or a MySQL client. What if you could build full-blown functionality with realistic data operations within the comfort of a Unit Test Harness?
What if this meant shipping code earlier and more frequently than you ever have before?
Building upon concepts outlined in this talk: http://bit.ly/tdd-talk-2, and leveraging an evolving "Kata" for building a "Ride-Hailing Application", this exercise will walk thru a rapid-development example from a "clean-slate" Symfony3 project, with just enough bootstrapping to enable Test-Driven Development with PHPUnit & Doctrine.
To get ready to follow-along the tutorial, please complete the "Initial Setup":
https://github.com/elchris/kata_tdd_php_symfony/blob/master/README.md

In this tutorial we are going to dive deep into PHP's Internals. It is appropriate for people that know PHP as a language well, but are interested into finding out what goes inside in-depth.
We will start by looking at how the language parser and scanner work, which convert scripts into an Abstract Syntax Tree. When then look at how PHP internal byte code is generated from this AST, and how the engine runs byte code.
After the introduction, we will working together on extending the PHP core with a new feature.
As a treat, we'll also have a look at the OPcache extension, and see which optimisations it does to generated byte code.
Reasonable knowledge of C (or similar languages) is required to make the most of this tutorial.
You will learn:

• How PHP works internally.
• How to extend PHP with a new feature.
• How OPcache does some of its optimisations.

WebSockets provides a way to have a persistent 2-way connection between your server and your client’s browser. This allows for more efficient communication than traditional front end mechanisms such as XHR or long polling and allows for better web-native applications as a result. Starting out with WebSockets in the browser has its complications, especially regarding how they can hook into your existing application.
The tutorial will cover the basics of WebSockets, and then move on to PHP workers and the React event library for PHP. Using these we can implement PHP clients as part of a WebSocket application, allowing your existing stack to communicate with a WebSocket server and your users in the browser. The tutorial requires no existing familiarity with WebSockets or event-based frameworks, though basic knowledge of JavaScript and a reasonable knowledge of OOP PHP and PHP via CLI are recommended.
Whilst the application will be generic there will be time to see how components could interact with your businesses existing projects, so you can deploy real-time applications to benefit your users with minimal overhead.

PHP is nothing like compiled languages. If you make a mistake, the program will crash when the line of code with the mistake is executed. When testing a PHP application, whether manually or automatically, developers spend a lot of their time discovering mistakes that wouldn’t even compile in other languages, leaving less time for testing actual business logic.
PHPStan is a popular static analyzer focused on finding bugs in your code. By leveraging the strength of PHP type system further enhanced in PHPStan itself, developers can create robust applications and discover bugs early in the development process. The aid the tool provides during refactoring is also indispensable.
In this workshop, the attendees will learn how to install, configure and run PHPStan, and also receive tips on how to write code so that PHPStan can be as powerful as possible. They will also be able to write their own PHPStan rules and extensions.

In this Live coding workshop session, we will develop a complete API from the scratch using Clean Architecture and Clean Code techniques. We will make sure the code can be tested and develop unit tests for it. We will discuss and make plans for additional features and APIs so these examples will grow into a real-life project.
Note: We will develop this project in pure PHP and explain how it can be used in a Laravel project using dependency injection.
Prerequisites: Bring your own laptop with your favorite IDE for PHP and Composer installed. We recommend PhpStorm (a free trial is also fine) - this will greatly speed up the development process.

Web security is an ever-changing landscape. Protect your infrastructure and your sensitive data with this 4-hour training. We'll start with the theory behind application hardening. We will then go through a multitude of common vulnerabilities, along with concrete examples and solutions. We'll finish with an interactive risk assessment session.

WebSockets provides a way to have a persistent 2-way connection between your server and your client’s browser. This allows for more efficient communication than traditional front end mechanisms such as XHR or long polling and allows for better web-native applications as a result. Starting out with WebSockets in the browser has its complications, especially regarding how they can hook into your existing application.
The tutorial will cover the basics of WebSockets, and then move on to PHP workers and the React event library for PHP. Using these we can implement PHP clients as part of a WebSocket application, allowing your existing stack to communicate with a WebSocket server and your users in the browser. The tutorial requires no existing familiarity with WebSockets or event-based frameworks, though basic knowledge of JavaScript and a reasonable knowledge of OOP PHP and PHP via CLI are recommended.
Whilst the application will be generic there will be time to see how components could interact with your businesses existing projects, so you can deploy real-time applications to benefit your users with minimal overhead.

When I first started to attend conferences I looked up to speakers as if they where unreachable rockstars or better yet Gods who descended on our little blue planet. All-knowing creatures to educate us mere mortals.
Let me tell you a secret… that’s not true! They are just like you and me. Down to earth people who want to share their knowledge and experience to help others. You can be the one on this stage too.
Impostor syndrome is just a mind trick. I’m sure you also have something interesting to share which will benefit others. And guess what? Conference organizers are always on the lookout for new talent.
I will show you how to get started. How to pick a first topic and craft your first talk; how to get confident on stage and benefit from public speaking. And let’s bust some myths along the way too, shall we?

Being a Lead Developer is a fun, interesting and responsible adventure. Becoming one is not something that happens from one day to the next. It is something that you grow into by raising your voice, taking action and responsibility. I've learned many things working as a Lead Developer, but I'd like to share 6 things, which were the most important for me.

The difference between a junior and senior software engineer is something we call “experience” - The experience is nothing more than choosing the *right* tools/practices for the right project at the right time.

This talk is about writing PHP Code that satisfies your project needs:

• When and how to design interfaces
• When and where you should use globals
• When and how to use static interfaces
• How to define testing granularity
• And much more

After this talk, you will be a better PHP developer. You will be able to approach code in a very pragmatic way, understanding when you should keep it simple.

Get ready for a 25 min live-coding session, where I go through practical examples that will make you understand that you don’t need to write complex code when you aren't gonna need it.

This talk not advocates for "no framework" as the title can misguide you. WFS is a presentation which guides the audience through bad practices and bad code examples developers applying to hide behind the common excuse of "Framework recommended way" or "Framework best practices".
Off course not all of the framework recommendation should be avoided, but there is some which bind application too much to the specific framework or specific framework version, to the extent that companies shaped their product in the shape of the framework.
The audience will face all issues related to binding an application to the framework, and they will be guided through the possible solutions.

• How to unbind your business logic from the framework
• Why is important to take the framework as a tool and not as a skill
• What is evil about annotations and magic inside frameworks

The main goal of Machine Learning is to create intelligent systems that can improve and acquire new knowledge through input. In practice, this translates into the use of one of the hundreds of different algorithms available. Based on the PHP-ML library I want to present different classes of problems and how to use them. I will also show you how to build an entire pipeline by which we go through all the ML stages: preprocessing, choosing algorithms, and evaluating its effectiveness.

A talk about sprint plan components (I'm not only talking about planning meetings!) and how to profit from meetings so the team's work is the most effective. I will show how important an element of each sprint are meetings; what are the roles and what they let us achieve. Most importantly, I'll show how the responsibilities are distributed and to whom the individual meetings serve.

As the amount of data we produce is continuously growing, we need also more sophisticated methods to elaborate them. Probabilistic data structures are based on different hashing techniques and provide approximate answers with predictable errors. The potential errors are compensated by the incredibly low memory usage, query time and scaling factors.
This talk will cover the most common strategies used to solve membership, counting, similarity, frequency and ranking problems in a Big Data context.

This talks addresses things that are a must if you want to destroy your team culture, development team and slow down your whole project. The experiences shared are based on the real world implementation of a microservice architecture.

You have an application in mind. You know what it should do. You may even have thought about how to implement the most interesting bits of behaviour. The problem is not one of technical knowledge but of organization; you know how to write the code but not where to put it.
The aim of this talk is to show you how to decide what belongs in a class, why Single Responsibility matters and a few well-known techniques that you can use to write code that embraces change.

Event Storming is simple and one of the most powerful techniques you can master. During this presentation, I will show you how to carry out your first session, go down to the design level and then transfer the acquired knowledge to working code.

If you've been in development for a while and you're anything like me, you probably still use MySQL in the same way as you did in the 3.x days - let's be honest, when was the last time you cracked open the MySQL documentation?
However, things have moved on, and these days there are some pretty awesome features in MySQL, from document store to spatial support and more, that would make your life easier, and your app faster - things that you could - or even should - be using.
Join Liam and discover what this modern MySQL looks like, and how you might use it to improve your applications.

Is your Doctrine too slow or using too many resources on the server? In this presentation, you will learn the memory, I/O and CPU usage of different approaches. You will also see learn how to create proofs of concept and benchmarks to make a decision based on science instead of your gut feeling. I will even show you how to automate your performance testing.

In the recent years we have seen a shift in software architectures. The monolithic approach slowly runs out of fashion and architectural concepts like microservices, API’s and decoupling in general are getting more and more important.
This talk will look at the different “new” approaches which can deliver a big benefit to your application’s architectural design. We will also dive into the disadvantages decoupling introduces into the software stack and how to overcome them.

Ansible is an IT automation tool for all the things which can quickly become boring for a php developer: cloud provisioning, configuration management, application deployment and much more.
I will give you a short introduction and overview how to automate things with the help of Ansible, so you can speed up all the "boring stuff" and simultaneously easily write a documentation.

A microservice architecture can bring a lot of pain, when it comes to versioning of services, APIs and Frontends. Unfortunately you can not really go without it, at least if you want to be with a stable system. This talk is based on a real world implementation, that covers everything from Services to Frontend to API to Document Format Versioning.

Once upon a time, Senior developer was the real role-model, a person that everyone looked up to, a developer that you seek for advice and wisdom. Nowadays, seniority is a synonym for large salaries and big egos.
Let’s have a trip down the memory lane and drift away from the money-driven mindset. Instead of that, let’s inspire you to be better developers who are fulfilled by knowledge, success, and accomplishments.

For the last couple of years I have been building, maintaining and fighting a projects that make use of distributed computing, parallel processing, message brokers, queues and workers. This is one of those "from the trenches" talks, where I will regale you with tales about the series of unfortunate events that may happen as your application grows in complexity. Tales like disk space fluctuations, importance of logging, NoSql problems, restructuring your order of execution in code for performance gains, short sighted albeit logical architectural decisions that will cost you in the long run.

Codeception testing framework wraps all levels of testing: acceptance, functional, and unit. It is very flexible and powerful and can be configured to work as with small PHP projects and with big ones. In this talk, Michael will tell some hints on building scalable tests architecture for PHP applications using Codeception. How to design tests, split them into levels and subprojects, and make tests effective and reusable.
Michael will tell us:

• how to write tests in a layered architecture,
• how to test project different bundles (microservices),
• real life example of building reusable tests architecture for e-commerce projects,
• why to use domain assertions in unit tests,
• how to set up parallel execution on CI,
• and build Selenium cluster with Kubernetes.

What if I told you that you don't need a 100% code coverage?
Compiled languages need to know about the type of every variable, return type of every method etc. before the program runs. This is why the compiler needs to make sure that the program is “correct” and will happily point out to you these kinds of mistakes in the source code, like calling an undefined method or passing a wrong number of arguments to a function. The compiler acts as a first line of defense before you are able to deploy the application into production.
On the other hand, PHP is nothing like that. If you make a mistake, the program will crash when the line of code with the mistake is executed. When testing a PHP application, whether manually or automatically, developers spend a lot of their time discovering mistakes that wouldn’t even compile in other languages, leaving less time for testing actual business logic.
There are several static analyzers available for PHP that substitute the role of the compiler from other languages. By finding bugs without even having to execute the code, they can save a lot of effort that'd be spent on tedious writing of boring unit tests. In this talk, I will share tips and tricks on how to structure your code to maximize benefits from using a static analyzer. You won't stop writing unit tests, but you will focus your efforts on areas where they count the most.

Frameworks are great tools. And Symfony is my beloved one. A lot of developers learn from them how to write applications nowadays. But framework documentation shows you framework approach. There is nothing wrong, as it’s framework documentation job. Unfortunately, a lot of developers don’t look for any other architecture approaches. They stick with what they have seen in framework documentation.
During this talk, you will see how the application and domain layers could look in a framework-agnostic approach. Usage of ports and adapters architecture will help us with that. What is more interesting, it's easy to integrate application decoupled from the framework with that kind of tool. You will see that on an example of Symfony. And from the time that we have Symfony Flex on board, it’s even easier in that case.

Out of the box, Kubernetes makes it easy to deploy and scale your applications within one Kubernetes cluster in one single region. But with the Kubernetes Federation API and the use of Service Meshes like Istio, it is also possible to deploy an application over multiple clusters in different regions, so that it becomes truly highly available, even if a complete region fails.
In this talk, you will learn how to set the Kubernetes cluster federation up and how to deploy your applications to make the best use it, especially regarding monitoring, persistent storage, latencies, data integrity.

Setup your local environment, setup the remote server, push the code, done. Your application is ready and deployed.
This talks is a walk-trough on how to setup a continuous integration and delivery pipeline to have your PHP code pushed right to production using modern CI tools and Docker Swarm.

Everybody was Git Fu developing, those bugs came fast as lightning. In fact, it was a little bit frightening, but they fought with expert rebasing. There were funky Developers from funky everywhere. They were merging bend up, they where merging bend down. It is a special developer art, and everybody knew their part. For my friend, ain’t your head is detached. Then I'm guiding you to a clean state. Everybody was Git Fu developing, those problems were solved as fast as lightning. Want to sing along and master your Git Fu. Listen to this lecture of sensei Sebastian.

We talk a lot about various architectural approaches and how to make our projects better when using them to achieve business goals and technical quality. Unfortunately, we don't talk as much about the environment in which we apply those techniques - the framework - and since they represent the crucial part which determines the amount of work, I think we should. In this talk I'd like to show you how Symfony can be used with virtually any kind of approach - DDD, CQRS, Event Sourcing, Hexagonal Architecture, and many more - and how well it fits in each of those use cases. There are no silver bullets, but some tools do a really good job of letting you take control, and Symfony is definitely one of them.

I've worked in many places with many teams, project managers and approaches to work. I've seen projects' ups and downs. I want to share that experience and show what doesn't work. Starting from the agile/scrum with poor implementation and micromanagement, through "strange, it works on my machine", "this doesn't need tests", "not invented here syndrome" to lack of knowledge sharing and no understating of "why" you're working on a given project. Management and developers are equally to blame here. I hope to share bad experiences from the past so you'll be able to recognize them in your future and avoid.
After this talk, if you observe any of these symptoms at your workplace hopefully you'll try to challenge them as soon as ASAP.

This talk is for developers who want to know how to debug their code in a better way, through single-step debugging, profiling, and simpler debugging tools.
Xdebug is a PHP extension that implements many debugging aids and features. In this presentation, we are going to look at this new version of Xdebug 3. The new version is a near-total rewrite and brings many improvements over its older releases. You will learn how to optimally use the new features and settings to make your development life easier.
Besides introducing the redone functionality, we will also have a cursory look at how these features are implemented, just to provide a better understanding of what a debugging extension, can, and cannot do.

"The closer you are, the less you see"
How often do you think you know a lot about PHP magic? And what if I tell you that you just did not look carefully? After all, the more you think that you know everything, the easier it is to deceive you. Look carefully, because the closer you are, the less you see.
The school of PHP magic opens its doors. Let's run beyond the established boundaries of OOP rules and make the impossible possible. And who knows, maybe you will love this magic: magic methods, non-standard ways of accessing properties, changing contexts, aspect-oriented programming, streaming filters, and more.

Working with legacy code is inevitable for 99% of developers and almost everyone has bad associations with it. But this does not have to be like this. Working with legacy code may be the most fulfilling one, challenging you on almost every step to write better, easier and more maintainable code. During my talk I will present one of the best approaches to working with legacy code. One that allows to smoothly transform a code spaghetti into a beautiful crafted codebase without loosing your mind. The approach is called Strangler Pattern and I will cover both the theoretical part as well as practice and lessons learned.

We're currently re-developing one of the most important components of Neos CMS using Event Sourcing and CQRS. In this talk, I'll show how Event Sourcing can be applied in practice.
First, I'll give an intro to Event Sourcing and CQRS, demonstrating the contexts it is used in; and explaining pros and cons.
Afterward, I'll demonstrate our real-world implementation of Event Sourcing in a complex problem domain, explaining our key insights.
After this talk, attendees will know the consequences of this architectural pattern in complex, long-living projects.

Have you ever wonder what distinguishes great developers from good ones? Is it a framework, lines of code produced per day or number of design pattern implemented? Don't get lured away! The one most important question outstanding developers ask themselves is: how I'm going to debug and maintain this in the production? Unfortunately, it's a factor, which is very often overlooked by many devs.
This broad-ranging talk will touch different aspects, which makes applications robust and easy to maintain. It will provide some also some directions regarding the development team work organisation. Last, but not least speaker will try to convince you that, there's some truth behind "The best code is no code".
The talk will be as much framework-agnostic as possible, backed with real-life examples.

Well designed and performant API's are key aspects of good and reliable application systems.

Especially when kicking of an API system it is really hard to setup and define all boundaries that are necessary to build a futureproof API. Changes later on can be time consuming and of course expensive.

Therefore it is extremely important to plan the API design beforehand and to use best practices and patterns from the industry.

In this session I will guide the listeners through the creation process of an API and will introduce and explain all important parts that constitute a battle tested and robust API. Things like middleware layers, security tokens are only some key points that will be presented on stage.

This guide is for agencies and site owners that currently don't have proper monitoring of their website health. I'll show you how to keep an overview. I'll cover installing Icinga 2, adding hosts and services one by one at first, then in massively automated ways with Ansible and Director.
While I will focus on Drupal 8 for my examples, the guide applies to sites written with any other PHP framework, too. Icingaweb2 itself is also written in PHP.
I'll guide you through the installation of Icinga 2. Repeat the steps at home, and you'll know:

• Is the site up?
• Get notified if it is not
• How to get a snapshot of my Drupal sites' status reports?
• How to calculate SLA update percentage - can you promise 99,9 % to your clients?
• Server health: hard disk, load, etc., & time series charts of all the things.

Most of developers are constantly teaching and discussing modern patterns, frameworks and libraries. But what if you think that you know almost everything about traditional OOP in PHP? I can bet that at some level of mastery you could notice that traditional object-oriented patterns do not solve all problems but introduce new questions instead. This is because OOP-way is not suited well for complex tasks.
Are you looking for the new food for thoughts about how such complex issues could be solved in PHP? For example how to make your existing method asynchronous just with one single word? Or how to reduce boilerplate code for feature toggles?
Join me and I will show you how to apply the most powerful aspect-oriented framework to escape from your existing OOP boundaries and teach you new patterns that can help you to keep your code clean.

Do you know, when you are writing a test, something isn't going right and you get a failure message "Failed asserting that false is true"? Let's see how we can improve our test's assertion in other to get more helpful errors by using dedicated PHPUnit assertions. We're going to see how we can make our suite of tests stricter, avoiding PHP's false-positives weakness. Also, we'll be seeing how PHPUnit works under the hood, from the assertion method to the verification itself.