The WordPress coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. development team builds WordPress! Follow this site for general updates, status reports, and the occasional code debate. There’s lots of ways to contribute:
Found a bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority.?Create a ticket in the bug tracker.
Hallway Hangout: Performance Considerations for Block Themes
As more is being done to work on performance as it relates to blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. themes, a hallway hangout has been planned to bring together folks from various backgrounds to see what else can be worked on, unblocked, and better understood. This is meant to be both a knowledge sharing and alignment creating session between folks from various areas including but not limited to @flixos90@adamsilverstein@spacedmonkey@youknowriad@desrosj@tweetythierry@oandregal@aristath.
At a high level, we’ll go through general intros (what each person does/focuses on), current work underway to address performance, what work is being done specifically for block themes, and general open Q&A. Hallway hangouts are meant to be casual and collaborative so come prepared with a kind, curious mind along with any questions or items you want to demo/discuss.
There’s difficulty in this work partially due to how backports happen from GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ to CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. both for finding and fixing regressions.
There’s still a big need to have solid measurements and track them in some level of granularity for both Core and Gutenberg.
There’s great potential in Block theme performance because of how they are built to improve performance.
Some level of changes in performance is okay but we need to avoid major regressions and not let perfect get in the way of good enough.
A Performance role for the upcoming 6.2 release squad should be considered to improve coordination between various teams and focuses.
Theme.jsonJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. performance & avoiding major performance regressions with merging Gutenberg into Core
We kicked the call off discussing issues in 6.1 around caching data in theme.json, which led to a broader discussion around merging Gutenberg into Core in a way that avoids regressions.
Andre shared how performance is measured in Gutenberg (typing, time it takes to load a big post, etc) for each release. You can see the results of each test in the various release posts under “Performance Benchmark”.
Some performance concerns for 6.1 happened only via manual testing. How can we automatically find this rather than needing to manually manage much of this work?
Testing needs to happen both in Gutenberg and with Core.
It’s not always easy to spot performance concerns in the Gutenberg pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party for a variety of reasons:
How code is ported from Gutenberg to Core making it hard to track problems down with this example shared of the kind of large backports that happen.
Iteration happens much faster on the Gutenberg side than Core.
Inconsistencies in results depending on the tool used.
A question was raised around whether there is load time performance tracking on the front end for Gutenberg. This currently doesn’t exist but it was agreed that it should be explored.
Tonya shared how iteration happens much faster on the GB side with Core happening less frequently so when we think about performance, we want to think about strategies for how we can do it on a faster basis. Let’s not wait until we get into Core and let’s retest when it gets added to Core.
Tonya’s team is working on improving the backporting process with sooner and smaller backports to Core to get them in throughout the development cycle. If it’s ready, backportbackportA port is when code from one branch (or trunk) is merged into another branch or trunk. Some changes in WordPress point releases are the result of backporting code from trunk to the release branch. it rather than waiting.
Part of this work is making sure Gutenberg back end code is Core ready (runs against same thing so when backports are ready to go, it’s Core ready).
Tonya is going to do a Make post to cover what her team is working on.
Jonny brought up confusion around where to make changes when performance concerns are found. This is a larger conversation and it was agreed to bring that discussion into a different space to preserve the conversation around performance.
Avoiding regressions in Classic themes & how performance is measured
Jonny is doing very manual testing to try to catch things as much as possible. Having automated tests would be huge along with being able to generate a spreadsheet comparing RCs, commits, etc.
Database queries are usually a sign that something is loading that shouldn’t be loaded. It’s not always obvious but it can act as an early warning sign that something isn’t working.
Joseph previously volunteered for the measurement side but got pulled into other things. It sounds like this is still a significant need to figure out, do measurements, and track them in some level of granularity (per day, per commit, per release) for both Core and the Gutenberg plugin.
Sergio shared more around the WordPress.comWordPress.comAn online implementation of WordPress code that lets you immediately access a new WordPress environment to publish your content. WordPress.com is a private company owned by Automattic that hosts the largest multisite in the world. This is arguably the best place to start blogging if you have never touched WordPress before. https://wordpress.com/ side of things with lots of tooling being run tools for WordPress.com servers which wouldn’t apply well to this situation since they are not particularly suitable to ongoing development.
Felix discussed measuring server side performance by using server timing metrics to see how many ms certain processes take. In theory, you could have something that could receive server timing metrics.
The performance dashboard for Gutenberg was discussed as a spot to make more robust and port in more tracking: https://codehealth.vercel.app/
The general topic of how to measure PRs to reflect real improvements in production came up with Andre sharing how depending on the tool used there are wildly different responses in performance impact.
Jonny brought up how complex this can get when you add in object caching, PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher versions, etc. Any performance metrics would need to have a matrix of configurations to cover cases.
In general, need to also look at regressions individually because they might be different to a different degree depending on environment.
Adam ended this section of the conversation with a great reminder that some level of small changes in performance in normal but we need to avoid major regressions. Let’s not let perfect get in the way of good enough.
Core web vitals and block themes. What parts of Core can be improved out of the box? What are we doing specifically around block themes?
Jonny shared that because of theme.json, Block themes are slower than Classic themes with work underway for them to be on par with Classic themes. There’s an amazing opportunity to do performance work with Block themes because everything is a block. You could prefetch image assets, ensure images above the fold are loaded, etc once you know entire markup of page before headers are sent.
Discussed various ways enhancements could happen with script and resource loading (CSSCSSCascading Style Sheets. file loading, font loading, etc) as well as lazy loading things as well beyond just images (what about CSS?). For example, if a block is in the footer of the page, could load later on.
Thoughts around better ways teams can work together around improving block themes.
In particular, this refers to the Core Editor, Core, and the Performance teams since we’re all ultimately a part of broader WordPress efforts and we can use our unique expertise to be better together.
Discussed having another hallway hangout specific for WordPress 6.2 items to have more practical, hands on things to go through.
Anne threw out the idea of having a Performance related role for release squad and will follow up to more formerly propose.
Jonny brought up ensuring folks are giving the time to respond during releases and to pingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” early. At the same time, Tonya reminded us to avoid having bottlenecks and to practice reviewing something after it’s merged to still fix what’s found.
Next steps:
@hellofromtonya will share a Make post about the work her team is doing at Automattic around more continually backporting items from Gutenberg into Core.
@annezazu will suggest a performance role on release squad (with +1 from Tonya, Jonny, and Thierry).
@annezazu will follow up with a 6.2 related performance hallway hangout once betaBetaA pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. 1 is released.
@adamsilverstein will share a Make post on an automated testing environment and possible steps there.
