Hallway Hangout: Performance Considerations for Block Themes

As more is being done to work on performance as it relates to blockBlock Block 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.

If you’re interested in joining, the Hallway Hangout will happen on 2023-01-10 14:30. a Zoom link will be shared in the #core-performance SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/. channel before starting.

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.

Recording

Attendees:

@flixos90 @adamsilverstein @spacedmonkey @tweetythierry @oandregal @priethor @clarkeemily @daisyo @greenshady @annezazu @scruffian @josephscott @mihai2u @joegrainger @delawski @sergiomdgomes @luminuu @hellofromtonya mukesh27 Felix Arnes, Didier Mahaux, and Simon (didn’t catch a last name).

Notes

Overall themes to the conversation:

  • There’s difficulty in this work partially due to how backports happen from GutenbergGutenberg The 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 CoreCore Core 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.jsonJSON JSON, 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 pluginPlugin A 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, backportbackport A 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

  • Adam brought up an example of a performance concern with Classic themes that has yet to be addressed: https://core.trac.wordpress.org/ticket/56990 
  • 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.com An 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, PHPPHP The 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. 
  • An example was shared of how to use the server-timing api in wordpress/gutenberg with an implementation of it to the Performance Lab plugin: https://github.com/WordPress/performance/pull/553 
  • 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.
  • Joseph brought up an issue around lazy loading LCP images that was implemented in a previous release but didn’t make it to block themes (only made it to classic). This is pending for the next release
  • Discussed various ways enhancements could happen with script and resource loading (CSSCSS Cascading 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 pingPing The 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 betaBeta A 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.

#hallwayhangout, #performance

Hallway Hangout: Editor Tech Lead role 101

Serving as Editor Tech Co-leads for WordPress 6.0, @zieladam and @gziolo not only shipped our most polished version of the BlockBlock Block 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 so far, but they also walked the extra mile to automate a lot of the legwork involved in the process 🎉

For WordPress 6.1, @czapla and @bernhard-reiter will be the Editor Tech Co-leads. Since it is a first for both of them, their predecessors have graciously agreed to walk them through the process.

As this knowledge might be valuable to others – especially future generations of Editor Tech Leads – @annezazu suggested turning this into a public Hallway Hangout that will be recorded and shared. Yours truly, serving as Co-release Coordinator in both 6.0 and 6.1, will join this merry band to facilitate.

In a nutshell, we will be covering the following topics from an Editor Tech Lead perspective:

  • Major versions vs. Minor versions
  • Minor version release process
  • Major version release process

If you’re interested in joining, the Hallway Hangout will happen on 2022-08-11 12:00; a Zoom link will be shared in the #core-editor SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/. channel before starting. We’d be especially interested to hear from previous Editor Tech Leads about their experience and advice! However, everybody is welcome to join to get a glimpse of the ins and outs of the Editor Tech Lead role and, who knows, maybe volunteer in a future release squad !💥

The recorded session will be added to this post once it’s ready.


Edit on August 12th: Recording is available.

Attendees: @bernhard-reiter, @bph, @czapla, @gziolo, @priethor, @hellofromtonya, @zieladam

Resources shown in the video:


Thanks to @bernhard-reiter for coauthoring and reviewing this post.

#hallwayhangout #6-1 #core-editor

Hallway Hangout Summary: “compare and contrast” the Navigation screens

This post summarises the Navigation screen Hallway Hangout held on 2021-08-24 09:00 UTC in Zoom facilitated by @get_dave, @talldanwp and @javier.

The blockBlock Block 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.-based Navigation editor screen has been behind an “experimental” feature flag within the GutenbergGutenberg The 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/ pluginPlugin A 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 some time. The purpose of the call was to outline the work required in order to remove the “experimental” status from the screen in order that the editor is active by default in the Gutenberg plugin.

The team working on the feature feel this is valuable in order to increase the visibility of the feature and therefore improve the quantity of feedback we receive.

Meeting Recording

If you’d like to watch the full recording of the session you can do so below:

Key points agreed

It was agreed that the prerequisite for removing “experimental” was: UIUI User interface/UXUX User experience feature parity with the existing Navigation screen (nav-menus.php) in CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress..

We also acknowledged that:

  • We wouldn’t commit to feature parity of developer focused APIs at this stage.
  • Removing “experimental” in the Gutenberg plugin, would not automatically make the feature ready for merging into Core (that won’t happen until WordPress 5.9 at the earliest).

What was discussed?

The format of the hangout was an open discussion comparing and contrasting the classic menu screen with the experimental block-based navigation screen.

To this end attendees were asked to test drive both screens and note down their findings prior to the call.

The meeting facilitators also prepared a list of items as discussion points which were worked through during the call.

Each item was demonstrated, discussed and then assigned a loose priority of High/Medium/Low based on how critical the group felt the issue was to achieving feature parity.

Outcomes

The key outcomes of the call were:

Next Steps

Contributors working on the Nav Editor will now look to reorganise and reprioritse the tracking issue around the problems identified during the call.

  • All items will be added to the tracking issue (with the possible exception of bugs).
  • The High priority section of the tracking issue will be reformed and refocused around the goal of “removing the experimental status from the Navigation Editor”. Only tasks directly related to this goal will be considered for inclusion in the “High” priority section.
  • Tasks identified during the call that were marked as Medium or High till be added to the aforementioned High priority section of the tracking issue.
  • Contributors will focus on tackling High priority tasks in order to realise the goal of removing the “experimental” status.

All contributors are encouraged to become involved in prioritisation. Everyone is welcome and we’d very much value your feedback. If you feel a priority is wrong or missing then please let your fellow contributors know.

Thanks to everyone who attended the hangout and we look forward to moving the Navigation Editor forward together.

#feature-navigation-block-editor, #hallwayhangout, #navigation, #summary, #video

Hallway Hangout: Fool me once — Writing end-to-end tests against regressions

On Thursday, I hosted a little walkthrough on how to write a simple end-to-end test to make sure a specific piece of editor functionality that had broken in the past wouldn’t break again.

As GutenbergGutenberg The 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/ grows, the project sometimes experiences regressions: Features that used to work suddenly don’t anymore. In order to prevent these regressions from happening, contributors can write end-to-end (e2e) tests that cover a given piece of functionality and alert us when that functionality is broken. Combined with a Continuous Integration system such as GitHubGitHub GitHub 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/ Actions, this is a very powerful tool, since it can notify a PR author that their PR might break something before they even merge that PR.

I’ve recently tried to keep more track of such regressions, and have started filing issues requesting e2e tests to cover them. In the hangout, I’ve picked one of these issues and demonstrated how to write an e2e test for it.

Continue reading

#core-editor, #e2e-tests, #gutenberg, #hallwayhangout