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.
Reminder: Performance team roadmap for 2023 https://github.com/WordPress/performance/issues/631 If you’re actively contributing to the WordPress Performance Team or plan to do so this year, please share your priorities for 2023 as a comment on this issue before end of day Wednesday February 15, 2023
Team rep nomination reminder, please add your nominations for Performance Team RepTeam RepA Team Rep is a person who represents the Make WordPress team to the rest of the project, make sure issues are raised and addressed as needed, and coordinates cross-team efforts. by Friday, February 24 2023
@joegrainger making good progress on the 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 Checker. We’re starting to finalise the infrastructure and should have a working plugin running some initial checks by end of the month. You can track progress on the GitHub repo and leave any thoughts/ideas you may have. The repo will be moved to the WordPress organisation when ready
Issues that completed and merged in feature/automated-performance-testing-mvpbranchbranchA directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a "branch", such as "the 4.0 branch"..
We will open a PR against the WordPress trunktrunkA directory in Subversion containing the latest development code in preparation for the next major release cycle. If you are running "trunk", then you are on the latest revision. once the initial version is complete. Feel free to take a look at the issues and leave any thoughts or ideas you may have.
@joemcgill Additionally, I’ve been starting to work on an experimental implementation of XHProf with wp-env to help make it easier for folks to do general performance profiling tasks. See: https://github.com/joemcgill/gutenberg/pull/1 as a starting point.
@10upsimon updates on Enhancing the Scripts APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. with a loading strategy
Documentation approved, although there was a comment added post approval that I have addressed. It does not change the work, but it does result in the need to confirm that the blocking strategy is not to be confused with the blockingscript attribute itself.
GitHub issues have been finalized and broken down into 4x milestones in a separate sheet, estimates are present for all issues in the sheet, although not all issues are in GH yet.
GH Issues and AC’s have been added to the project board for Milestones 1, 2 and 3 and have been assigned to @joemcgill for review. It looks like all except for one have been approved (at the time of writing) as they’ve been moved to the backlog
I’m in the process of breaking down issues for Milestone 4
TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress.ticketticketCreated for both bug reports and feature development on the bug tracker. to be posted by Friday, I see no risks thereto.
Engineering will commence next week on Milestones 1, 2 and 3
JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. & CSSCSSCascading Style Sheets.
@olliejones I’ve been hammering on the low end persistent object cache, looks good.
@aristath These past couple of weeks I continued working on the SQLite database implementation. There’s a lot of work to do, but things are looking good. Started collaborating with @zieladam as well in an effort to improve some things and make the implementation more stable.
@flixos90 Reminder that the PL 2.0.0 release is going to be on February 20 (as usual, the 3rd Monday of the month)
@flixos90 There are still 2 PRs in the milestone that haven’t seen any updates in a while: https://github.com/WordPress/performance/pulls?q=is%3Aopen+is%3Apr+milestone%3A2.0.0 Friendly 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.”@aristath and @adamsilverstein to please follow up if we want to get them into the 2.0.0 release
@flixos90 update on Unbundling the Performance Lab plugin
Separately, there are already a few engineering efforts which we can start, regardless of the exact outcome in the above discussions. I opened a number of issues and started to add proposed requirements:
Please take a look, it would be great to get more feedback on the engineering approach for unbundling
We can keep discussing the approach on the issues, but preferably we should begin working on code for at least the first issue next week, to not have this stagnate
@flixos90 Just sharing here that I discovered (probably?) a major performance regressionregressionA software bug that breaks or degrades something that previously worked. Regressions are often treated as critical bugs or blockers. Recent regressions may be given higher priorities. A "3.6 regression" would be a bug in 3.6 that worked as intended in 3.5. in 6.2 for classic themes: https://core.trac.wordpress.org/ticket/57648
I’m going to follow up on that ticket shortly to collaborate with @oandregal as he is seeing slightly different results. Of course there is a chance that something specifically in my analysis went wrong, but we will have to validate that data
Performance team roadmap for 2023 https://github.com/WordPress/performance/issues/631 If you’re actively contributing to the WordPress Performance Team or plan to do so this year, please share your priorities for 2023 as a comment on this issue!
@flixos90 Anyone that is more or less regularly contributing to the team is asked to think about and share their priorities for this year, if possible
@spacedmonkey There is also SQLite database and object cache that are in play
@flixos90 I think SQLite is clearly a focus. What is on the issue right now is not at all a complete roadmap. The idea is that anyone can post comments with what they would like to prioritize
@olliejones It’s my impression that almost nothing, except @flixos90 contributions, are on the priority list yet. So, it’s up to the rest of us.
@flixos90 Exactly, I just posted 2 things that we already have proposal posts for, as a starting point. So yes, it’s explicitly a call for anyone involved in the team to contribute to this roadmap
@spacedmonkey One thing I have not discussed publicly, but want to look into lazy loading meta data in core. We have a problem that more and more WP_Queries are being run per page and lots of post meta is being loaded when not needed https://core.trac.wordpress.org/ticket/57496
The 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/ team recently added TTFB measurement to their repo, which is being collected in the code health dashboard here: https://codehealth.vercel.app/project/1. It’s making visible the performance regressionregressionA software bug that breaks or degrades something that previously worked. Regressions are often treated as critical bugs or blockers. Recent regressions may be given higher priorities. A "3.6 regression" would be a bug in 3.6 that worked as intended in 3.5. in 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. theme rendering when compared with classic themes for a simple “hello world” page. As a team, we would like to make sure we’re properly prioritizing the tickets we have for 6.2 that would positively impact this metric—particularly anything that we need to land before the 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 milestone next week.
@joemcgill I think much of the work for 6.2 that was focused on improving server response times for block themes has already been merged, but I’m mindful of the beta milestone coming next week and want to help prioritize helping land anything that I can that is still in the air.
@spacedmonkey me and @flixos90 have worked a lot on block theme performance. Any questions on what I am working on, please feel free 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.” me
@joemcgill Main thing is whether there are any enhancements that still need to land that you’re waiting on review for?
@clarkeemily we also have the Bug Scrub tomorrow at 16:00 UTC time where we can talk through other 6.2 performance items
@mukesh27 Is anyone on the Gutenberg team checking those regressions, or do we have to?
@joemcgill Good question. I think they are, but there’s no reason we shouldn’t take a look every so often. Really, it would be nice to do something similar for CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.
@mukesh27 Are those changes incorporated into the core of WordPress?
@johnbillion I’d love to do something similar for core, the main problem is how to avoid variance so the reporting over time is accurate
@flixos90 We have talked about it before in that recent hallway hangout earlier in January. In fact @adamsilversteinis working on a Make post that should go out this week
@spacedmonkey I would also have some way of query count per page load.
@joemcgill I think long term variance is a concern, but maybe not a blockerblockerA bug which is so severe that it blocks a release. as long as the short term trends are instructive/useful.
Plan to have quick-fire focus area updates (15m) so we can focus the remainder of todays chat on Next steps for Unbundling the Performance Lab 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 (proposal)
@joegrainger Still making good progress on the Plugin Checker, starting to approach the remaining issues on the infrastructure so will soon be in a position to run some of the initial checks and do some testing. Feel free to track progress on the GitHub repo and leave any thoughts/ideas on issues. The repo will be eventually moved to the WordPress organisation when ready.
JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. & CSSCSSCascading Style Sheets.
TL:DR; the team are in agreement to proceed with working towards splitting out standalone plugins and keeping the Performance Lab plugin as it is for now
Detailed conversation below:
@flixos90 We are still waiting to get feedback from Matt on the 3 alternative options that we have outlined and discussed earlier in January. However, I think it would be unwise to just wait and do nothing until we hear back, for which we don’t have a timeline. Therefore my proposal is to work towards simply splitting out standalone plugins and keeping the Performance Lab plugin as is for now
A bit more context on the reasoning behind that proposal: The “for now” here is important, as that would likely be a temporary solution. Doing so is effectively our option 1 that we voted for in https://github.com/WordPress/performance/issues/618#issuecomment-1377598692, but the main reason I’m proposing to already work towards it here is that that option is the least disruptive and the least effort, and even if we eventually go with option 2 or 3, we would need to implement the same changes as part of that
It is also the most natural transition, for example @aristath‘s SQLite standalone plugin has already been broken out as a standalone plugin
The idea is that with the above we would work in the right direction no matter what the eventual final outcome should be. And in any case we would not be wasting time doing work that would potentially not be needed
@joemcgill So, if I’m understanding properly, you’re proposing that the performance lab plugin would still include the modules that have been split out. Correct?
@joemcgill What other plugins need to be split out that aren’t already?
@flixos90 I think that we need to discuss. But first I wanted to get feedback on the general idea I shared above. Is that a reasonable next step, as a temporary measure to work in the right direction?
@johnbillion Does that duplicate any work or is there a handy build/deployment step for publishing the separate plugins?
@flixos90 We would have a build step that simply replaces module headers with plugin headers and deploys those as individual plugins. All modules already work standalone, so there’s no extra work involved in that regard. The main work would be to implement the build and deployDeployLaunching code from a local development environment to the production web server, so that it's available to visitors. step.
@joemcgill At least the SQLite integration plugin is already moved to a separate repo, so it’s a bit clunky to have some of these modules in a mono-repo and some not. It would be nice to align on a development approach.
@flixos90 Absolutely; if we go with this approach, we would likely move the SQLite repo back into the PL repo (just for development, the plugin repos on .org would of course remain separate)
@johnbillion +1 on a monorepo otherwise we introduce more metaMetaMeta is a term that refers to the inside workings of a group. For us, this is the team that works on internal WordPress sites like WordCamp Central and Make WordPress. problems maintaining separate repos
No other thoughts on the above from todays meeting, @flixos90 based on the feedback above I think it’s reasonable to proceed with this option for now, to work in the right direction. What we should discuss then though is our approach on how to break out modules as standalone plugins (which we already started talking about a few weeks back)
@joemcgill My initial question is whether all modules should be standalone plugins, or if some of them are better suited to stay as part of central infrastructure or smaller experiments as “core modules” of the performance plugin?
@flixos90 Exactly, I would outline these alternative ways to go about it:
Every module becomes a plugin?
Some modules are grouped together into “focus” plugins?
Only some modules get broken out as a plugin?
@olliejones Specifically, does it make sense to have a standalone “Enhanced Site Health” plugin containing the various site health modules?
@flixos90 Potentially. Though my personal take is that we should avoid grouping modules as then we are still going the slippery slope of not having individual plugins for individual features. FWIW, we used to have plugins like https://github.com/audrasjb/site-health-audit-enqueued-assets, and I think that’s the most appropriate approach, even if those plugins are extremely niche
@joemcgill Personally, I would keep things like audits, health checks, and small feature experiments like fetchpriority in the main plugin, and break out larger feature plugins.
@flixos90 If we do this, we won’t fully address the request of having individual plugins for individual features. What if someone just wants to test fetchpriority? Yes, it’s much simpler than e.g. WebP, but I’m not sure that justifies going a different route for the two
@joemcgill That may have been a bad example, and also the part that I’m least confident about, but seems it would be nice for us to have a place to experiment with smaller changes that we are thinking of proposing as enhancementenhancementEnhancements are simple improvements to WordPress, such as the addition of a hook, a new feature, or an improvement to an existing feature. in core and not have to spin each one out to a separate plugin until/unless it matures to the point where it’s warranted.
@flixos90 Ah okay, that idea sounds interesting. Certain things could start out as a module in the PL plugin and only become plugins as they mature?
@olliejones So, PL contains stuff that’s bound to be included in core, AND stuff that’s bound for standalone plugins? Is that right? Or is the criterion for putting a module into PL still that it is bound for core?
@joemcgill Right, or if they’re a large enough feature that it makes sense being its own thing. I would say the SQLite persistent cache fits that qualification for me
@flixos90 All of that would be things to be included in core. Whether it’s a module in the PL plugin or a standalone plugin is just different ways to “test-drive”. So if we did that, we would still have a mapping that a module can be mapped directly to a standalone plugin, but we would decide for each module whether/when to do that on a case by case basis?
@olliejones Is that too limiting? Is Matt thinking along the lines of Drupal’s Core Modules? Is that the direction his “canonical plugins” want to go? Should this team stay away from doing stuff UNLESS it’s bound for core? That’s what I mean. There’s plenty of perf work that only applies to some installs, not all. Like the persistent object caches. Maybe like webp.
@flixos90 we can totally work on things that are not for core; for example the plugin checker project we’re working on. It’s just that the scope of the Performance Lab plugin has been for features targeted for WordPress core. Of course it can always happen that a feature is never deemed eligible or ready. But features in the PL plugin should have the intent to land in core eventually
Conclusions: @flixos90 I think we are converging on the approach of “decide on a case by case basis for each module whether/when it becomes a standalone plugin”, but it’s been only a short conversation with few voices heard, so maybe we can defer a hard decision until next week; I’ll summarize in https://github.com/WordPress/performance/issues/618 and we can keep discussing there
@adamsilverstein not much to update from my end this week. I have been mostly thinking about/planning for WordCampWordCampWordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. Asia & contributor dayContributor DayContributor Days are standalone days, frequently held before or after WordCamps but they can also happen at any time. They are events where people get together to work on various areas of https://make.wordpress.org/ There are many teams that people can participate in, each with a different focus. https://2017.us.wordcamp.org/contributor-day/https://make.wordpress.org/support/handbook/getting-started/getting-started-at-a-contributor-day/., coming up with a plan for that. I’d love feedback about good ways to engage new contributors on performance
@joegrainger: been away for a few days but have been making progress on the 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 Checker infrastructure. Still more to be done, but you can see the work carried out here https://github.com/10up/plugin-check (we’re developing the project here, but will be eventually moved to the WordPress organisation).
The plugin checker will be run through both the CLICLICommand Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress. and the WP Adminadmin(and super admin). Feel free to take a look at the issues and leave thoughts/ideas you may have
JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. & CSSCSSCascading Style Sheets.
@aristath Last week, SQLite was released as a stand-alone plugin. No announcement action etc was taken. I left that TBD so we can coordinate our policy and strategy as a performance team. The submission was done early to get a head-start with the plugin review process etc – which made sense since this was a direct request from Matt.
@olliejones The SQLite DBMS project is going to require large-scale testing to get to 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. status
@spacedmonkey asked where is the best place to provide feedback for this plugin – best course of action to create an issue here https://github.com/OllieJones/sqlite-object-cache/issues
@flixos90 Note that we now have both the separate GitHubGitHubGitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/ repo and the module in the PL GitHub repo, so we need to figure out how to handle that. The duplicate code between those 2 repos is certainly not good
@spacedmonkey noticed that cache values were not being set
@flixos90 No recent updates, however I opened https://github.com/WordPress/performance/issues/627 yesterday. What I’m proposing in that issue is to bump the minimum version requirement of Performance Lab to WordPress 6.1. This will allow us to remove the two Site Health cache modules that were already launched in WordPress 6.1, which at this point are a bit of unnecessary baggage to still have in there
Note that per our version support policy our commitment is to only support the latest WordPress release anyway, so this should be okay
Discussion around plugin versioning:
@flixos90 I see there’s a suggestion by @joemcgill to potentially have a 1.10.0 with that code being deprecated first. I don’t think that would help here. FWIW, the modules are already not loaded today when you have WP 6.1. So nothing changes for you either way when they’re removed:
Either you are on WP <6.1, so you cannot update to the new PL release.
Or you are on WP 6.1, which means you already are using the coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. feature, and the PL modules for the same purpose are not loaded.
@joemcgill Makes sense to me. Just getting up to speed on the process here now that I have time dedicated to work on these performance projects. The documented policy seems quite clear
It’s a standalone plugin. Does it make sense to build it into PL, to put it onto a track to go into core?
@spacedmonkey I think it needs to live as a plugin for a while
@flixos90 A bit of a tricky question. Of course we are working towards unbundling the PL plugin. But we’re still pending a decision on how exactly, and at this point it may make sense in the PL plugin. Is it already published on wp.org or not?
@olliejones Absolutely live as a plugin. There’s no other way to get decent field experience. And this kind of thing requires field experience.
@spacedmonkey I want to test it on bigger sites, multisitemultisiteUsed to describe a WordPress installation with a network of multiple blogs, grouped by sites. This installation type has shared users tables, and creates separate database tables for each blog (wp_posts becomes wp_0_posts). See also network, blog, site, ensure cache invalidation works, support wp_cache_get_multiple and some other stuff
@flixos90 Okay, we should definitely keep it published like that then. I think at this point, let’s just keep it like that? We could potentially add it as a PL module too, but depending on the path decided on for unbundling the PL plugin, that would just be unnecessary work – so probably most efficient (until we have a decision) to work in its own repo for now
@spacedmonkey discussed the TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress.ticketticketCreated for both bug reports and feature development on the bug tracker. for making php 7.2 the minimum version of support php in WordPress https://core.trac.wordpress.org/ticket/57345 and asked if this is something we should be pushing for as the performance team
@olliejones I say yes, smaller QA matrices are always good
@joemcgill It could certainly have some positive performance implications, though I’m not sure how much impact we would have since the process for bumping versions is pretty well established (unless I’m wrong). It would be nice to help support that effort with some evidence about the performance benefits from any automated testing we do against different versions.
@adamsilverstein One new thing this week: I am working on a game/testing tool that shows two images generated by WordPress and asks users which they prefer. The comparisons will cover a range of quality settings and mime types (and image engines) and we will collect data about the comparisons. My goal is both to have something fun and interactive as well as get some actual WordPress based data on image quality to help make a decision about where to set WebP default quality in coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. I’d love to have some testers/feedback here once I get it a little further developed (to be shared in future).
@pbearne I will/plan create a combined patchpatchA special text file that describes changes to code, by identifying the files and lines which are added, removed, and altered. It may also be referred to as a diff. A patch can be applied to a codebase for testing. with dom-color with theme flags and media lib changes for core and then create a new proposal blogblog(versus network, site) post on make for this new version Following from @flixos90comment on the media lib patch
@spacedmonkey asked if we are hoping to get dominant color into 6.2
@pbearne would love to get it in but @spacedmonkey unsure if the 80% rule was met (is it useful for 80% of users)
@pbearne I am hoping as this is a enhancementenhancementEnhancements are simple improvements to WordPress, such as the addition of a hook, a new feature, or an improvement to an existing feature. to the media library and the is for every one we can get it in and with the them flag it can be pulled into a theme if wanted just like you might use the icons from core in a theme
Basically, to get template / template parts for 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. theme, you have do a database query per part
This can result in 10+ queries per page, even after queries are cached
I am wondering if it makes sense to just load all template parts in single database query and them filterFilterFilters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. using PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher
The only worry is that you may load templates you do not use or you might have say 40 templates. But that seems unlikely
Templates are not like content, there will not be 20k templates. The benefit of using one query and one cache
@joegrainger: 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 Checker work in progress (mainly infrastructure right now) and coming along nicely
JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. & CSSCSSCascading Style Sheets.
@olliejones I’m seeing some very promising performance results from using SQLite as the persister for an object cache. Is this worth proposing as a Performance Lab module?
Performing very well on a WooCommerce site on low-end Godaddy hosting – been doing some tests on my 100K user test site, it seems good. Also works with multisitemultisiteUsed to describe a WordPress installation with a network of multiple blogs, grouped by sites. This installation type has shared users tables, and creates separate database tables for each blog (wp_posts becomes wp_0_posts). See also network, blog, site
@mxbclang: This week’s chat will be dedicated to discussing next steps on Matt’s request to split out features from Performance Lab (see blog post comment, Slack, and GitHub issue). We’d like to hear opinions on the three options outlined in the issue so that we can ultimately hold a vote and make a decision on how to move forward.
Discussion: Unbundling Performance Lab
@flixos90: Want to emphasize that we should decouple how we develop these features from how we distribute them, with this conversation focused on the latter. We can keep working in a mono repo to keep development overhead low no matter which approach we choose for distribution.
@olliejones: It seems like any attempt to figure out what a “canonical 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” is might be a waste of time, as it’s up to Matt, not us
@flixos90: The canonical plugins topic is related but not really connected. Agreed it’s not on us to decide, but also don’t think we need to do that to determine how to unbundle Performance Lab. The ask is to distribute the features as individual plugins – whether or not they’ll become “canonical” plugins isn’t directly relevant to the unbundling.
@flixos90: As comment notes, we’ve considered three options so far:
Option 1: Keep PL as is, but additionally deployDeployLaunching code from a local development environment to the production web server, so that it's available to visitors. modules as individual plugins
Option 2: Make PL a “wrapper” focused on central infrastructure and recommendation of individual plugins
Option 3: Deprecate PL completely in favor of individual plugins
@masteradhoc: Don’t see SQLite as something that needs to be in PL and WebP can also be standalone. How do you define if a feature should get into the plugin or be standalone? Would go for option 3 to keep everything separated and have some sort of list to keep track on what is being worked on. However, this still doesn’t solve the bigger issue – what happens if the argument is still to not merge them into coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.? What will make a canonical plugin in the end? How can we really move WP further in performance?
@flixos90: The idea is that all modules of PL are standalone features, so option 3 would mean each module would become its own plugin. The PL plugin has a lot of benefits that we would lose if we go with this option, which is why it’s the most unfavorable to me. There are several feature plugins that weren’t merged into core – either they continue to be developed to eventually get there or they get archived.
@masteradhoc: In that case, think more of option 2. Wouldn’t do option 1 as it seems like duplication.
@flixos90: Yes, there would be duplicates, but it’s not necessarily bad. It’s the best of both wolds, similar to how Jetpack works as of today.
@spacedmonkey: Could a feature be both a standalone plugin and in PL?
@olliejones: We have one canonical plugin now, Akismet, that’s available to every WP install but not required – is that what Matt wants for performance?
@flixos90: Nothing would be pre-installed; let’s focus on unbundling as opposed to canonical plugins since we don’t know what those are
@spacedmonkey: It seems to only make sense to break off larger feature like WebP or SQLite into separate plugins
@masteradhoc: I wouldn’t install a plugin just to get additional Health Checks
@flixos90: It’s a blurry line – it would require the overhead of a discussion on every single feature to decide if it should be a standalone plugin. Would be in favor of a single consistent decision to save ourselves the overhead later. This is how feature plugins have always worked. FWIW several plugins have only ~50 installs because they’re so specific.
@spacedmonkey: Could have a Performance Lab module and a GH repo template for them, would help with maintenance
@joegrainger: If we deploy modules as individual plugins, will they have their own repos and if so will they be in the WordPress organization?
@flixos90: Yes, only on wp.org would there be separate repos
@mxbclang: Are we comfortable that keeping PL anddeployingDeployLaunching code from a local development environment to the production web server, so that it's available to visitors. separate plugins fulfills Matt’s request? We would still have a single plugin with all of these features
@flixos90: We’ll have to see of course, but main ask was individual plugins
@adamsilverstein: Not sure this really meets his requests, he very explicitly said of SQLite that we should “stop putting additional things like this into Performance Lab”
@flixos90: From my perspective, since Jetpack does Option 1, this should be a reasonable approach
@spacedmonkey: Jetpack is an example of a mono repo with multiple plugin projects: https://github.com/Automattic/jetpack/tree/trunk/projects/plugins, which is a good example of how Option 1 would work
@kraft: Jetpack system uses composer packages for things shared between plugins and they get called in via them, happy to answer any questions about the setup
@mxbclang: Option 3 is also a burden for support, since each plugin has its own support forumSupport ForumWordPress Support Forums is a place to go for help and conversations around using WordPress. Also the place to go to report issues that are caused by errors with the WordPress code and implementations. that would need to be monitored
@spacedmonkey: Marketing is also an issue, where do we push people to?
@flixos90: Depends on the context, likely PL primarily, but individual plugins would also be available. A feature proposal post would highlight both as equal options for testing.
@olliejones: Option 1 lets us keep moving on development, but it carries the risk of Matt pushing back
@flixos90: FWIW both Options 1 and 2 carry that risk
@flixos90: Benefit of Option 1 is that it would continue to work as is for the people who have PL currently installed; Option 2 would require a complex migrationMigrationMoving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. that users likely would not understand
@adamsilverstein: Good point, thinking more of the end user who hasn’t tried “feature X” yet and having a separate plugin might be a better experience
@flixos90: Options 1 and 2 would be have separate plugins for each module
@spacedmonkey: Having each functionality in its own plugin helps with testing
@spacedmonkey: What defines a module? Would the current Site Health checks all be together, for example? SQLite and WebP are clearly their own modules, but what about smaller things?
@flixos90: Great question and another thing to discuss for the future
@spacedmonkey: Defining how we break the plugin up helps with what option we pick – don’t want a bunch of “sub”-plugins
@flixos90: Yes, but this doesn’t affect which option we choose
@olliejones: Plugin discoverability is a huge issue in today’s WP ecosystem and Option 1 helps discoverability. The categoryCategoryThe 'category' taxonomy lets you group posts / content together that share a common bond. Categories are pre-defined and broad ranging. “canonical plugin” does seem to help with discoverability.
@flixos90: Fair to say that discoverability would suffer with Option 3.
@spacedmonkey: Marketing and support would also suffer
@adamsilverstein: Not sure about discoverability, if I want a SQLite feature for my site, a canonical plugin that does just that would be easier to discover than a feature within PL
@flixos90: Yes, but the standalone plugin would always exist with any option
@spacedmonkey: If there’s a standalone plugin, will anyone bother with a PL plugin? What’s the point of it?
@flixos90: Depends on the audience. There are people that want one feature at a time and others who want everything in one place.
@olliejones: Happy with Option 1 for now. Taking a step back, discoverability is a REALLY big problem for WP themes, plugins, etc. The reason I suggested working on the definition of “canonical” is that it has the potential to address that. Know that we can’t solve that problem but it’s what Matt cares about.
@masteradhoc: Agree, maybe next meeting could focus on how these initiatives can be moved forward
@spacedmonkey: Personally think that all PL functionality should be opt-in
@adamsilverstein: Love the idea of canonical plugins at install time, Drupal does something exactly like this with their 10-minute install
@flixos90: That’s how I’ve been thinking about canonical plugins, as well, with WP core providing contextual recommendations
@spacedmonkey: Maybe we could have a setup wizard where you opt-in to the features that you want, like Web Stories
@olliejones: Is there any way to get Matt’s approval of our choice, or do we have to do a bunch of work and risk it getting shot down?
@flixos90: We’d definitely reach out to him with a proposal once we have alignment within the team; we wouldn’t start any work before having buy-in from him
@mxbclang: Next week’s chat will be dedicated to discussing next steps on Matt’s request to split out features from Performance Lab (see blog post comment and Slack)
@spacedmonkey: Would really like eyes on https://github.com/WordPress/wordpress-develop/pull/3793, this was a bug introduced in 6.1 with WP_Query caching and want to get merged for 6.1.2
@spacedmonkey: Created a few issues for bugs/improvements that would be good first bugs:
@joegrainger: 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 Checker work in progress and coming along nicely
JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. & CSSCSSCascading Style Sheets.
@flixos90: Matt’s request will be a major Infrastructure topic. Will leave some thoughts on https://github.com/WordPress/performance/issues/618 so we can begin to discuss, but a real discussion should occur in next week’s chat since it’s more synchronous. See also @tweetythierry‘s reply to Matt here which mentions some potential options for us to think about.
@olliejones: Is there any prospect of getting coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. to add a new drop-in slot to avoid overloading object-cache.php with the monitoring stuff?
@flixos90: Adding a new slot will be challenging; defining the scope and whether it’s justified will likely take quite a while. That said, worth exploring in a TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress.ticketticketCreated for both bug reports and feature development on the bug tracker., but should probably come up with a solid proposal first.
@manuilov: If we need to split the plugin, seems like the most appropriate option is the second approach suggested by Thierry. Will need to extract modules as individual plugins and keep PL as a wrapper focused on central infrastructure and recommending individual plugins. Otherwise, if we deprecate PL, people will be less able to find new modules/plugins.
@spacedmonkey: Company that was sponsoring to work on the team has pulled out; as of January 31, will not be sponsored. Will be around but won’t have much time to commit to this project. Focusing on the tickets listed below. These are all around adding/using caches in coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. functions and will have a large impact, especially for big sites. Hoping to get some across the line before February.
@flixos90: Server-Timing APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. launched in Performance Lab yesterday!
Received a report of a conflictconflictA conflict occurs when a patch changes code that was modified after the patch was created. These patches are considered stale, and will require a refresh of the changes before it can be applied, or the conflicts will need to be resolved. with W3TC around the object-cache.php file that we’ll investigate. Our approach is to maintain the other file, but maybe their check for whether the file is in place is overly strict.
JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. & CSSCSSCascading Style Sheets.
@olliejones: Are there any plans to create an ingestion module to move MySQLMySQLMySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored. https://www.mysql.com/. contents to SQLite?
@mxbclang: Good question for Ari, maybe comment on his post?
@joegrainger: Started engineering on 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 Check this week, building out initial infrastructure
Should help us significantly in assessing server timing metrics in the field; we’re currently extremely limited in that regard as the usual tools only give us client-side performance metrics
For example, other than baseline PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher execution time and DB query time metrics, it also includes one more specific metric, to measure the autoloaded options query (which will help us assess the potential impact of https://github.com/WordPress/performance/issues/526)
Very large PR (like SQLite) so the more reviews the better, hoping to merge tomorrow for 1.8.0, otherwise will need to puntpuntContributors sometimes use the verb "punt" when talking about a ticket. This means it is being pushed out to a future release. This typically occurs for lower priority tickets near the end of the release cycle that don't "make the cut." In this is colloquial usage of the word, it means to delay or equivocate. (It also describes a play in American football where a team essentially passes up on an opportunity, hoping to put themselves in a better position later to try again.) to 1.9.0
Will be part of the plugin’s infrastructure, so other modules will be able to leverage it to add server timing metrics around their own behavior and validate how much a certain module improves server-side performance in the field
JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. & CSSCSSCascading Style Sheets.
Proposal from @adamsilverstein on a new approach; please take time to review and comment
@adamsilverstein: Next step is a ticketticketCreated for both bug reports and feature development on the bug tracker./code proposal, thinking a new TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. ticket might be best
@spacedmonkey: Is there a plan to use the defer APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. in coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. themes and plugins? Useful for developers to see it in action and provide a good example
@adamsilverstein: Yes, that’s the plan, to use it wherever we can in core, including themes
@spacedmonkey: Might be worth reaching out to the 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/ team to see if 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. editor could use this
@adamsilverstein: Greg was always asking for it and commented on the original proposal; will be sure to keep them in the loopLoopThe Loop is PHP code used by WordPress to display posts. Using The Loop, WordPress processes each post to be displayed on the current page, and formats it according to how it matches specified criteria within The Loop tags. Any HTML or PHP code in the Loop will be processed on each post. https://codex.wordpress.org/The_Loop.
@johnbillion: Have any scripts in default themes been identified as being able to support defer? Probably fewer can support async
@adamsilverstein: For sure things like commenting script, but haven’t looked at core themes yet. Probably lots of things in wp-adminadmin(and super admin), as well.
@olliejones: @aristath finished the SQLite module https://github.com/WordPress/performance/pull/547 and we would welcome additional testing in advance of Monday’s release
@flixos90: Important to test the user experience on module activation. You’ll get an entirely new DB with some added logic to make the transition as seamless as possible. This is only the install; no content migrationMigrationMoving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies..
@spacedmonkey: Do we run unit tests with SQLite enabled?
@flixos90: We don’t, but that’s a great idea. Maybe we can add an extra scenario to the GH action for PHPUnit that always has the SQLite database active so we can spot any inconsistencies.
@flixos90: A few PRs have landed that fixed some issues with tests since PHP 8.2 caused breakage; kudos to @mukesh27 for working on those
@adamsilverstein: Proposed a new plan for A/B testing capability in the plugin https://github.com/WordPress/performance/issues/597 and would appreciate feedback
Gutenberg plugin version 14.7 is released and available in the Plugin Directory (First 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 release by @daisyo) 👏
@hellofromtonya shared a Webfonts APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. Status
“Still in re-design of the architecture phase. Close to merging the first re-architectural PR. What does it need?
Test it with plugins that are using the current functions to ensure nothing is broken, ie back compatibility is maintained with this phase.
Final code review
Then merge
Once merged, it will unblock the last re-architectural task. Once both of those are merged, then performance tasks are unblocked.”
“We now have the basics of the Navigation List View working. It is possible to view, edit and remove navigation items from the inspector controls. Drag and drop also works. The main areas of concern are:
When editing an item, can we show the settings tab?
Can we animate the opening of the 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. settings to make it clear that this is conceptually a “drill-down” operation?
Work continues on exploring fixed/sticky support for container blocks in: [WIP] Add a Position support (including sticky), decoupled from layout #46142. The current exploration now decouples the concept from Layout, as there are potential future use cases for non container blocks (e.g. one day being able to set relative/absolute, to position images for example). There’s still more discussion/work on this topic and a few blockers to resolve, so updates will happen over in the tracking issue for that feature here: Fixed Position Header and Footer Template Parts #30121 (comment)
— Upgrade ReactReactReact is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org/. Native to version 0.69.x (finished via these changes)
@flexseth posted: “Documentation review: There are quite a few discrepancies in the ESNext flavor syntax used in Code examples for the documentation (and handbook). Maybe the #docs channel would be the best place to take up discussion on that though? I’ve been wanting to make sure all of the examples are functioning and writing more examples for components.. and to also look to establish a standard for the ES6+ code out there.”
@bph noted: “An issue or more than one should go to the 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/ repo for discussion. If you want to work on fixing them, you can review the the Guide to Documentation contributions“
Open Floor
@flexseth asked: “Do you know where first time contributors can submit to be listed as contributors for this year? In the contributor numbers for State of the WordState of the WordThis is the annual report given by Matt Mullenweg, founder of WordPress at WordCamp US. It looks at what we’ve done, what we’re doing, and the future of WordPress. https://wordpress.tv/tag/state-of-the-word/., in one of the Hallway Hangouts a call for contributors was mentioned I think.”
@bph: noted: “AFAIK the contributor numbers in SOTW are always release related. 5.9 6.0 6.1. Each team has their own way of acknowledging contributions. 6.1 was the last release for the year. Every Gutenberg plugin release has a list of contributors, too. Example, including first contributors”
Well after having used WordPress for over 10 years, I can say the direction of the project is the best I’ve seen. Good work all! — @flexseth
@adamsilverstein: New ticketticketCreated for both bug reports and feature development on the bug tracker. to ensure coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. support for WebP is complete: #57328
When WebP was introduced to core, the implementation focused primarily on the most common use – lossy images. Part of the reason is that although WebP supports lossless compression, alpha transparency and animation as a format, actual support in WordPress depends on the underlying graphics engine (GD/Imagick) where support for these is more varied (for example GD only supports lossless WebP since version 2.3.3 and PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher vs 8.1). Furthermore, detecting support for these features of the format is difficult or maybe not possible.
If anyone has the bandwidth to dig into this issue, guessing we can improve the current implementation to better match the expectations outlined in the ticket.
@spacedmonkey: Working on theme.json issues, following code paths and making that code faster. Looping back on adding caching to WP_User_Query (adding tests) and migrating get_pages to use get_posts. Committed:
JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. & CSSCSSCascading Style Sheets.
@mxbclang via @flixos90: Aiming to complete Server-Timing PR including testing this week, so pending that will request reviews by end of week. Reviews already welcome and much appreciated, particularly around how the APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. looks and behaves.
