Speaking

Through both theoretical principles and practical real-world examples we’ll examine what performance and scalability mean from a server-side development perspective and how you can optimize for them.

We’ll cover basic mechanisms like profiling, deferred processing and caching first to make sure we got the big chunks out of the way.

Then we’ll dive deeper into code that simply needs to run faster or in a more scalable way, covering things such as loop optimization, static data, opcaches and other mysterious concepts.

The Open Web, as impactful as it is for our society, is currently in danger and has been for while now. There is a constant pressure from walled gardens and app stores to monopolize on information, at the detriment of all but a few. Nothing new on that front, right? We all know by now how important the Open Web is and that we need to safeguard it, especially in the WordPress community. Yet here we are, still keeping on doing the things that hurt the Open Web, and supporting the platforms that endanger it.

In this talk, we’ll look past the bare minimums of accessibility and performance to discuss how UX and monetization relate to each other, and how an healthy Open Web might need to look for alternative business models.

(Image courtesy of Caspar Hübinger)

Joining such a welcoming and inspiring community as is the WordPress project can be exhilarating and makes people want to contribute their part to join the movement and strengthen their feeling of belonging.

The initial enthusiasm can easily lead to contributors slowly spiraling into overcommitment and a feeling of obligation and responsibility towards the project. There’s a cost attached to anything we do, even when we’re talking about unpaid volunteer work done in spare time. And that cost will be paid in some way, no matter what.

We need to more openly talk about the adverse effects of doing open source contributions in an unsustainable way, destigmatize the money topic when it comes to “free” software, and directly address immediate issues of frustration and burn-out as they surface.

Let’s all have our fellow contributors’ backs, and make sure we’re all in it for the long run!

The PHP DOM extension provides an object hierarchy that allows you to manipulate an XML or HTML document in a safe and structured way. Some of that object hierarchy is even extensible.

During my work on the AMP PHP toolbox, I created a whole abstraction layer on top of the DOM hierarchy to both fix all sorts of shortcomings or bugs, and to add convenience functionality that makes the rest of the code cleaner or more resilient.

In this talk, I’ll cover how the extension mechanisms work, where they don’t actually work at all, and what we did to produce a somewhat coherent abstraction layer that lets you provide a specialized API to modify documents.

Some of the use cases covered:

• abstractions providing clean APIs
• optimizations that cache state behind the scenes
• stronger type-hinting – automatic transcoding to UTF-8
• fixes and polyfills for libxml bugs and compatibility issues
• convenient access to and automatic generation of expected elements

Google recently introduced the concepts of Core Web Vitals and Page Experience scoring and via its latest updates has added these as ranking signals to their search engine.

Briefly put, if your site is not both performant and user-friendly, you’ll have trouble ranking in the search results. 

In this talk, we’ll cover briefly what this Page Experience update means for web publishers before diving deep into the different methods you can use to measure and optimize the Core Web Vitals and the Page Experience scores for your web assets running on PHP servers or frameworks.

In this talk, I’ll share the principles I work hard to adhere to when designing and maintaining open source packages meant for public distribution. It covers topics like dependency management, filesystem/namespace structure and standards adherence.

In this talk, I’ll share the principles I work hard to adhere to when designing and maintaining open source packages meant for public distribution. It covers topics like dependency management, filesystem/namespace structure and standards adherence.

This talk presents optimization techniques that make the most of the PHP parsing and compilation into bytecode using techniques like code generation of classes that are loaded from opcache. This moves heavy processing from runtime to compile-time, making runtime extremely fast and efficient.

Backward compatibility and technical debt seem to be at odds in the long-term maintenance of a project. Take WordPress as an example; the project draws a lot of its success from the fact that it jumps through hoops to maintain backward compatibility. Most WordPress sites can be smoothly updated to the latest version of WordPress Core with the click of a button. However, this compatibility comes at a steep price: through this absolute priority on backward compatibility, the project sets itself up to continuously accumulate technical debt in the process. The effects of this are increasing effort to maintain the codebase and increasing difficulty for adding new features. What users perceive as the best quality is the greatest weakness in the eyes of a developer. This talk will first go through the logistics of maintaining a project with high technical debt like WordPress. Then it will examine what this means for projects that depend on WordPress. Finally, it will go through some potential ways of moving to a more balanced process, with a closer look at how WordPress finally managed to get away from its PHP 5.2 requirement.

While the general consensus is that you should absolutely use exceptions in your PHP for dealing with error conditions, there is very little information on how to actually structure and manage them in a larger codebase. The larger and more complex your projects become, the more important it is to start with a proper structure to avoid expensive refactoring later on. Your client will surely be thankful! This session will first discuss the nature of exceptions, and then go over how you can set them up in a larger codebase. Finally, we'll go over a series of tips that help you maximize maintainability and extensibility.

Backward compatibility and technical debt seem to be at odds in the long-term maintenance of a project. Take WordPress as an example; the project draws a lot of its success from the fact that it jumps through hoops to maintain backward compatibility. Most WordPress sites can be smoothly updated to the latest version of WordPress Core with the click of a button. However, this compatibility comes at a steep price: through this absolute priority on backward compatibility, the project sets itself up to continuously accumulate technical debt in the process. The effects of this are increasing effort to maintain the codebase and increasing difficulty for adding new features. What users perceive as the best quality is the greatest weakness in the eyes of a developer. This talk will first go through the logistics of maintaining a project with high technical debt like WordPress. Then it will examine what this means for projects that depend on WordPress. Finally, it will go through some potential ways of moving to a more balanced process, with a closer look at how WordPress finally managed to get away from its PHP 5.2 requirement.

While the general consensus is that you should absolutely use exceptions in your PHP for dealing with error conditions, there is very little information on how to actually structure and manage them in a larger codebase. The larger and more complex your projects become, the more important it is to start with a proper structure to avoid expensive refactoring later on. Your client will surely be thankful! This session will first discuss the nature of exceptions, and then go over how you can set them up in a larger codebase. Finally, we'll go over a series of tips that help you maximize maintainability and extensibility.

Through both theoretical principles and practical real-world examples we’ll examine what performance and scalability mean from a server-side development perspective and how you can optimize for them.

We’ll cover basic mechanisms like profiling, deferred processing and caching first to make sure we got the big chunks out of the way.

Then we’ll dive deeper into code that simply needs to run faster or in a more scalable way, covering things such as loop optimization, static data, opcaches and other mysterious concepts.

Joining such a welcoming and inspiring community as is the WordPress project can be exhilarating and makes people want to contribute their part to join the movement and strengthen their feeling of belonging.

The initial enthusiasm can easily lead to contributors slowly spiraling into overcommitment and a feeling of obligation and responsibility towards the project. There’s a cost attached to anything we do, even when we’re talking about unpaid volunteer work done in the spare time. And that cost will be paid in some way, no matter what.

We need to more openly talk about the adverse effects of doing open source contributions in an unsustainable way, destigmatize the money topic when it comes to “”free”” software and directly address immediate issues of frustration and burn-out as they surface.

Let’s all have our fellow contributors’ backs, and make sure we’re all in it for the long run!

Modern infrastructure technologies like serverless computing and real-time databases offer a huge potential for new and improved online user experiences.

In this session, we’ll go through a practical use case to find out how we can harness their power in the context of WordPress.

We’ll build a Gutenberg block that shows status updates, to be incorporated into a status page. We’ll use serverless computing to allow adding status updates via a Slack command, and we’ll use a real-time database so that all visitors receive these updates in real-time without any impact on our WordPress server.

WordPress is planning to raise its minimum PHP version requirement and if all goes according to plan, we will have a required minimum of PHP 7+ for December 2019.

Few plugin developers currently know how to make the best use of the language features that PHP 7.2+ provides. That’s why I worked on a new plugin boilerplate that provides you with a robust, strictly typed OOP framework and incorporates a lot of applied best practices.

In this session I will introduce this new boilerplate and go into the details of how this will improve your plugin code and reduce its maintenance cost in the long run.

WordPress is planning to raise its minimum PHP version requirement and if all goes according to plan, we will have a required minimum of PHP 7+ for December 2019.

Few plugin developers currently know how to make the best use of the language features that PHP 7.2+ provides. That’s why I worked on a new plugin boilerplate that provides you with a robust, strictly typed OOP framework and incorporates a lot of applied best practices.

In this session I will introduce this new boilerplate and go into the details of how this will improve your plugin code and reduce its maintenance cost in the long run.

Gutenberg is a major change to how you will develop software for WordPress. It starts with the WordPress editor but is planned to slowly take over the entire admin interface.

If you already have existing plugin or theme code that you need to maintain and make ready for the upcoming Gutenberg update, you will probably face some architectural design challenges.

This talk will first provide an overview of the general concepts that govern development in the Gutenberg era, and then discuss the different tricks & techniques you can use to gradually move your existing code from here to there, in a clean transition.

Gutenberg is a major change to how you will develop software for WordPress. It starts with the WordPress editor but is planned to slowly take over the entire admin interface.

If you already have existing plugin or theme code that you need to maintain and make ready for the upcoming Gutenberg update, you will probably face some architectural design challenges.

This talk will first provide an overview of the general concepts that govern development in the Gutenberg era, and then discuss the different tricks & techniques you can use to gradually move your existing code from here to there, in a clean transition.

WordPress draws a lot of its success from the fact that it jumps through hoops to maintain backward compatibility. Most WordPress sites can be smoothly updated to the latest version of WordPress Core with the click of a button.

However, this compatibility comes at a steep price: through this absolute priority on backward compatibility, the project sets itself up to continuously accumulate technical debt in the process. The effects of this are an increasing effort to maintain the codebase and an increasing difficulty to add new features.

Let’s examine how these two factors interrelate and what this means for WordPress’ current state and future evolution.

The WordPress REST API lets you move data in and out of WordPress – enabling integrations with any other client application or data consumer. We’ll guide you on how to design, create and execute custom endpoints in the REST API to enable complex integrations for multiple resources and clients.

In this workshop, we’ll create a fictitious project – we’ll be outsourcing the development of the app, whilst we focus on creating and providing the data from WordPress. We’ll start by designing the required data models and a communication protocol to transfer from server to client – then we’ll document our requirements to pass on to our outsourced app provider.

Once we receive the app back from our provider – ready to accept data – we’ll build the backend implementation to covers proper data models and custom REST API endpoints.

Attendees will learn how to design their WordPress backend to properly power a mobile app as well as how to putting together requirements that allow them to outsource non-WordPress development work for the custom client.

Requirements

Attendees are assumed to have a working WordPress development environment where they can develop and test a custom plugin, and have a git client that they can use to clone a git repository and switch branches.

Panelists:

• Mika Epstein
• Alain Schlesser
• David Lockie
• Tammie Lister

You know a lot of pattern buzzwords and OOP syntax, but fail to get actual benefits out of their practical use? You've read about principles and best practices but cannot apply them to your daily problems?

We'll work on a simple WordPress plugin to discuss fundamental principles like dependency injection and discover useful design patterns that solve real pain points in your development work. We'll combine these techniques to give you strategies to better deal with ever-changing requirements.

This workshop assumes solid knowledge of PHP and basic knowledge about classes and objects, how the PHP OOP syntax works and what the notions of polymorphism, encapsulation and inheritance mean.

Design Patterns in software engineering are a huge help for developers, providing a common, shared vocabulary across languages and platforms that facilitates communication and reasoning.

Due to their very nature, they are rather abstract and difficult to properly assimilate and apply in a practical context.

This session will discuss the construction of a real WordPress plugin while using several of the more common Design Patterns to demonstrate their real-world usage and highlight the benefits they provide.

Composer is a hugely flexible tool that works reliably on all but the most obscure hosters/platforms. What’s more, it provides a plugin system that lets you pull external code from a repository and have that code hook into the normal Composer execution flow. The logical conclusion is that Composer is used for much more than just pulling in dependencies.

We’ll start this session with a quick look at the basic mechanisms that make Composer as flexible as it is. Then, we’ll go through some of the more useful and/or exotic examples of how to use Composer for solving problems that it wasn’t really meant to solve.

This 90 minute WP-CLI workshop will be split into two halves. The first half will introduce users to the effective use of WP-CLI, including best practices for implementation and usage, how to effectively manage a website with WP-CLI, and tips and tricks for reducing the time you spend managing WordPress.

The second half of the workshop will cover writing your own commands for WP-CLI in PHP, including writing and using tests, writing effective documentation and how it’s used, and considerations for interoperability and input/output formatting.

Members of the WP-CLI team will be presenting, instructing, and helping attendees with tasks that are set as part of the workshop. They’ll be on-hand to provide guidance, assistance, and answer questions from attendees.

The workshop will be wrapped up with some fun uses for WP-CLI.

The workshop is aimed at developers and site maintainers who have at least some familiarity with the command line, but have yet to dive into using WP-CLI effectively or have yet to write their own commands.

If you’ve already started using WP-CLI but aren’t yet familiar with all the things that it can do, this workshop will also be useful for you.

Attendees are expected to have a working WP-CLI installation *prior* to attending the workshop (either on their own laptop or on a remote machine which they can access during the workshop), along with a web server that can run WordPress. There will not be enough time during the workshop to cover the initial installation of WP-CLI.

Wheels... we reinvent them on a daily basis. This is true in a lot of fields and activities, but it seems exceptionally common in WordPress development.

Computer Science has been around for longer than most people assume, and the simple truth is that most problems you could possibly encounter have been solved already... decades ago!

This session tries to give a brief glimpse into the timeframes and the usefulness of Computer Science as a discipline, and wants to make the point for looking at known solutions first before reinventing the next few wheels.

As the plugins you develop grow bigger, you need to spend more effort on getting the structure just right, to keep the plugin maintainable and easily extensible.

This session will briefly go over several key concepts of dealing with growing plugins, like using Composer to split your plugins into multiple reusable libraries or using a dependency injector to make the code independent of any specific implementations.

The session assumes knowledge of basic OOP principles and is an unofficial follow-up to the session "OOP Plugin Development Basics" held at WordCamp Nijmegen 2017.

Composer is a hugely flexible tool that works reliably on all but the most obscure hosters/platforms. What's more, it provides a plugin system that lets you pull external code from a repository and have that code hook into the normal Composer execution flow. The logical conclusion is that Composer is used for much more than just pulling in dependencies.

We'll start this session with a quick look at the basic mechanisms that make Composer as flexible as it is. Then, we'll go through some of the more useful and/or exotic examples of how to use Composer for solving problems that it wasn't really meant to solve.

Building WordPress plugins in an object-oriented way presents some particular challenges, due to the fact that the WordPress APIs you’re coding against are mostly procedural in nature.

In this session, we’ll go over a real-world plugin to see how the code should be structured, and how best to hook into the WordPress lifecycle when you want to take full advantage of the benefits of OOP PHP.

The WordPress bootstrap process is only scarcely documented, with only a very select group of developers that truly know the ins and outs and historical reasons behind the individual bootstrapping steps.

This session presents a detailed overview of the exact execution flow that launches your WordPress site on each page request, giving you detailed insights into:

• the order in which files are loaded
• how & why the different global constants are set up
• what functionality is “pluggable” and can be replaced by custom implementations
• how the database is connected
• how caching is set up
• how localization is set up and loaded
• how a multisite (network) is identified and loaded
• how the Plugin API is initialized

The session will end with a presentation of a feature project that aims to re-design and improve the existing bootstrap process.

If you manage more than one WordPress website, you might have experienced situations where you needed to do the exact same operation on multiple websites. If you were clicking through the sites one-by-one and thinking that there should be a better way to manage what you are trying to do, I’ve got good news: there actually is!

WP-CLI lets you control your WordPress sites through the command line, allowing you to do any operation across an arbitrary number of sites. This can save you minutes, hours, days or even weeks of work.

I’ll start with a small introduction to the command line itself, and then continue with very easy and common scenarios where WP-CLI can save you large amounts of time with little to no effort.

WordPress has pretty much anything it needs to fulfill normal CMS requirements. However, most client websites grow organically to include more and more business processes into the WordPress application lifecycle, which ends up being problematic at best.

WordPress does not provide the proper architecture and mechanisms to deal with business processes in a reliable and scalable way.

This talk presents a case study of wrapping a legacy WordPress site into a scalable architecture, using a combination of existing and custom packages, that provides the following benefits:

• services architecture that lets plugins define their dependencies, with automatically resolved loading order
• auto-wiring dependency injection that allows coding against interfaces instead of implementations
• configuration management that can account for differences in environments
• centralized logging throughout the entire site that can be sent to logging servers
• bus system that handles events and commands without blocking the frontend
• all of this without any noticeable impact on content editors

The end result is a WordPress site that embraces most of the commonly accepted PHP best practices, while still offering the same well-known editing UX to content editors.

Everyone knows that you need to write reusable code to be able to grow as a developer, right?

However, most developers struggle to understand how to split up their code to make it truly reusable, so they end up copy-pasting parts of code and modifying as needed, instead of effectively reusing the code that was already written, without a single change.

This session explains the concept of Config files and how they allow you to cleanly separate reusable code from project-specific code.

Everyone knows that you need to write reusable code to be able to grow as a developer, right?

However, most developers struggle to understand how to split up their code to make it truly reusable, so they end up copy-pasting parts of code and modifying as needed, instead of effectively reusing the code that was already written, without a single change.

This session explains the concept of Config files and how they allow you to cleanly separate reusable code from project-specific code.

Developers tend to get lost in technical details.

In a system as complex as a WordPress website, where there’s a lot going on behind the scenes, it can be a very valuable exercise to take a step back and analyze the different components of the whole system. This lets you get a sense of what part of the system is responsible for what end goal.

This session will give beginning and intermediate WordPress developers an overview, first of general web development, and then for the specific case of WordPress. We will briefly cover client-server architecture, and later discover how the different parts of WordPress work together to let you build sites and apps with relative ease. As it turns out, most of the skills you acquire with WordPress are valid for other domains as well, as long as you can look beyond the terminology.

My experience has shown that understanding the big picture makes it a lot easier to deal with the details, and I hope this will be true for you as well.