PHP Developer Day 2024

The keynote of this year's PHP Developer Days was given by Juliette Reinders Folmer, co-author or initiator of the tools PHPCompatibility and PHPModernizer, and a regular speaker at PHP events for many years. She talked about how the dependency on open-source components in a company's software architecture can become a problem when their maintenance relies on the shoulders of a few so-called maintainers who do this voluntarily and in their spare time.

It is becoming increasingly difficult to find people who are willing to do this task, and the willingness of companies to provide resources to their developers for this task is decreasing. The result is overloaded maintainers who withdraw from projects, which in turn can trigger a chain of problems in the form of security vulnerabilities. This brings to mind the case of the so-called XZ-Utils backdoor from spring 2024, where it was exploited that there was only one maintainer. Under the pretext of supporting him, a spy function was smuggled into his project, which had over 20 million accesses.

Juliette emphasized that Open Source thrives on the community and their engagement, and gave tips on how maintainers can organize themselves and support projects. It is crucial to be aware of dependencies, contribute to the project, and understand that maintainers pay with their time and nerves for everything that does not flow financially into Open Source projects.

Sebastian Bergmann is the creator of the tool PHPUnit, which has been used by PHP developers worldwide for two decades and is considered essential in the development process by many. In his talk, he mentioned that while most people are familiar with the basics of this tool, only a few truly understand its depths.

With PHPUnit, so-called unit tests can be carried out, which allow to verify whether the code works as intended on different levels. Sebastian demonstrated some of these tests live and explained how to perform them in everyday programming. Additionally, Sebastian presented the new features of the current version of PHPUnit, which make testing even more efficient.

A small time travel was the lecture by Sebastian Kurfürst, who has already contributed to open-source technologies such as TYPO3, Neos, and Flow in his long career as a developer. Using his own story, he showed how to write good code that can still be well maintained and further developed after years.

One should place great importance on ensuring that the code is explicit and unambiguous, and that programming patterns are functional and intuitive. Additionally, the code must be well-documented so that it is easily understandable not only for others but also for oneself after a long time. It is important to note that one should not necessarily document what a function does, as this is usually evident from the code itself. Instead, it is crucial to capture the purpose and goal of a function.

Furthermore, one should keep the code consistent and deterministic, meaning functions should fulfill a task without side effects and be balanced in terms of input and output. Finally, he introduced some concepts for writing code that he had good experiences with in the past and recommended always sitting down as a team to discuss code.

Even though every developer has their own ideas of clean code, it is talks like the one by Sebastian and events like the PHP Developer Day that provide enriching inspiration in this regard.

In his presentation, Sebastian Feldmann described the intermediate stage of a monolithic application on the way to a software architecture outsourced into microservices - the "modulith". Similar to a monolith, it is a self-contained application, but unlike a monolith, it is internally clearly structured into modules. These modules contain code and encapsulate specific functionalities, but have low dependencies on each other, making them easier to change or maintain individually. However, unlike a collection of microservices, a modulith is deployed as a single unit.

A system of microservices, according to Sebastian, may be more flexible and easier to scale, but not necessarily immune to structural errors. Outsourcing all functions to microservices can ultimately lead to unnecessary complexity. Especially when dependencies arise between the services, the fundamental idea of such an approach is undermined. Therefore, it is advisable not to immediately break down a monolith into microservices, but to take the intermediate step through a "modulith" that can then be more easily and controlledly transitioned to the desired state.