I wanted this to be multi-row, a grid instead of just one row. The code natively contained an option to include up to 12 featured posts, which could easily be made to wrap around to new rows, but the problem was, the background of the entire section containing all rows changed when you moused over a post, not just the single row, and I wanted not just a row-by-row background, but I wanted potentially unlimited rows.

I moved the code that generates the rows into a function, and then called it repeatedly, once for each row I want. At some point I may make it automatically add as many rows as are required to display all posts, but as of this writing, every time I add one more post than there is room for, I edit the bottom of this file to add another row.

Furthermore, originally, the theme CSS was really sloppy:

1.) There's a lot of identifying things by element, such as anchor or div tags, which the CSS then had to look up the ancestry of to see which formatting applied (as in rules similar to, "#page .hero-row .hero-slider

/**

* Default post thumbnail image.

*

*/

function mk_filter_thumbnail_id( $thumbnail_id, $post = null ) {

if ( ! $thumbnail_id ) {

$thumbnail_id = 289; //id of default featured image

}

    return $thumbnail_id;

}

if (! is_admin() ) { //don't do this on admin pages, it sometimes overwrites thumbnails in the back-end view of the media library

add_filter( 'post_thumbnail_id', 'mk_filter_thumbnail_id', 20, 5 );

}

By the way, I still haven't grasped what the third and fourth parameters of add_filter() do... I copied them out of a Stack Overflow answer and they worked. Wordpress's whole "filter" functionality is an odd way of calling functions, although I suppose it's a practical if roundabout way of hooking into existing functions to add your own code modifications.

I created a shortcode that does this (well, modified a shortcode, originally from the Hierarchical HTML Sitemap plugin, by Alexandra Vovk & WP Puzzle) and soon my site was happily generating dynamic menus on the fly and keeping up with my work as I added pages, edited titles, and rearranged categories.

And, along the way, getting slower.

And slower. And slower.

Finally the other night, due to a confluence of circumstance, it took me over a minute to load the front page. "This," I said, "has got to go."

Fortunately Wordpress includes something called "transients", which allow you to quickly store and retrieve temporary values. I figured, the shortcode that generates the menus—as well as a number of others, such as the Recent Kwits section that appears in the sidebar of internal site pages—really don't change that often. The menus in particular are very calculation intensive... in addition to traversing the category tree and listing the pages, they calculate the number of words on each page (you did notice that mousing over a menu item shows you how many words the page is, didn't you?) which means not just loading and counting the page, but expanding every shortcode in the page body, to count the words they generate too. It's a lot. It certainly doesn't all need to be recalculated on the fly every single time any page loads. So, I thought, if I could keep track of when the last content update was that actually required them to be updated (such as changes to a page, post, category, or tag), I could otherwise store the value in a transient. Transients are not reliable, they can get wiped out occasionally, but considering that the worst that that can cause is having to recalculate them one time, it's not a huge worry. (As a bonus, for you serious wordpress geeks, if you have an object cache installed, transients are stored in memory, rather than in the database, for even better performance.)

Long story short, that's what I did. I used the Query Monitor plugin to time my page loads, and with various optimizations to the server I run this site on, I had gotten the time "time to first byte"—the delay for the server to calculate everything before it could start serving the front page to the browser—down to about 4-5 seconds.

After the below optimizations, time to first byte immediately dropped to a little over a second.

And there was much rejoicing.

It works like this. I've got a plugin I wrote, imaginatively called "MK Custom Plugins", which contains all my custom plugins. At the top of that file is this:

/*
 * Plugin Name: MK Custom Shortcodes
 * Plugin URI:        https://michaelkupietz.com/plugins/the-basics/
 * Description:       My custom shortcodes.
 * Version:           1
 * Requires at least: 5.2
 * Requires PHP:      7.2
 * Author:            Michael Kupietz
 * Author URI:        https://michaelkupietz.com/
 * License:           GPL v2 or later
 * License URI:       https://www.gnu.org/licenses/gpl-2.0.html
 * Update URI:        https://michaelkupietz.com/my-plugin/
 * Text Domain:       mk-plugin
 * Domain Path:       /languages
 */


// first, some useful functions


add_action( 'save_post', 'setLastUpdateTimestamp' );
add_action( 'create_category', 'setLastUpdateTimestamp' );
add_action( 'edited_category', 'setLastUpdateTimestamp' );
add_action( 'delete_category', 'setLastUpdateTimestamp' );
add_action( 'create_post_tag', 'setLastUpdateTimestamp', 10, 2 );
add_action( 'edited_terms', 'setLastUpdateTimestamp', 10, 2 );
add_action( 'delete_term', 'setLastUpdateTimestamp', 10, 3 );
add_action( 'trash_post', 'setLastUpdateTimestamp' );

function setLastUpdateTimestamp() {
if ( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE ) {
        return;
    }
    // If this is a revision, don't do anything.
    if ( wp_is_post_revision( $post_id ) ) {
        return;
    }

 set_transient( 'mkFuncTransient_LastUpdateCheck',microtime(true),2592000); 
}

function latestPostUpdate() {
     $theDate = get_transient( 'mkFuncTransient_LastUpdate_all'); 
     if ( ! (isset($theDate) && $theDate > 0)) {
         $theDate=microtime(true);
         set_transient( 'mkFuncTransient_LastUpdate_all',$theDate,2592000);  //dont expire for 1 month }
     }
     return $theDate;
}

function getFunctionTransient ($functionName,$arguments=[]) {
     //call with: $transientData = getFunctionTransient(__FUNCTION__,$arguments); if ( $transientData != null) {return $transientData;}
     //the $arguments term in the call is optional. It's only for functions that return different values based on their arguments, so you can cache and retrieve the values of different calls with different arguments.
     $data = get_transient( 'mkFuncTransient'.$functionName . hash( 'sha512',json_encode( $arguments ) ) ); //per https://daext.com/blog/improve-the-shortcode-performance-with-the-wordpress-transients-api/
     $lastUpdate = get_transient( 'mkFuncTransient_LastUpdate' . $functionName . hash( 'sha512',  json_encode( $arguments ) ) );
     $lastPostUpdate = latestPostUpdate();

     if ( $data !== false and $lastUpdate < $lastPostUpdate ) {
          return $data;
     } else {
          return null;
     }
}

function setFunctionTransient ($functionName, $value = null, $arguments=[]) {
     //call this right before returning value of function with as: setFunctionTransient(__FUNCTION__,$returnValue,$arguments);
     //you can leave out returnvalue, or set it to null, to delete the transient.
     //the $arguments term in the call is optional. It's only for functions that return different values based on their arguments, so you can cache and retrieve the values of different calls with different arguments.
     if ( $value === null) {
          delete_transient( 'mkFuncTransient'.$functionName . hash( 'sha512',json_encode( $arguments ) ) );
          delete_transient( 'mkFuncTransient_LastUpdate' . $functionName . hash( 'sha512', json_encode( $arguments ) ));
          return $value;
     } else {
          set_transient( 'mkFuncTransient'.$functionName . hash( 'sha512',json_encode( $arguments ) ) , $value , 2592000); //dont expire for 1 month
          set_transient( 'mkFuncTransient_LastUpdate' . $functionName . hash( 'sha512', json_encode( $arguments ) ), latestPostUpdate(), 2592000 );
          return $value;
     }
}

[ ... the rest of my shortcode routines follow here ... ]

OK! Clear as mud, right? Here's all you need to know. I have a menu generation shortcode that originally looked something like this:

function hierarchicalsitemap_shortcode_htmlmap($atts, $content = null) {
     .... a bunch of fancy PHP to generate the menu HTML from the categories goes here ....
     $out = [result of above code];
     return $out;
}

add_shortcode("htmlmap", "hierarchicalsitemap_shortcode_htmlmap" );

So, once I had written the functions to handle transients, the only changes I had to make were to add three lines to the existing function, two right at the beginning and one before the "return" statement:

function hierarchicalsitemap_shortcode_htmlmap($atts, $content = null) {
     $origAtts=array($atts,$content);
     $data = getFunctionTransient(__FUNCTION__,	$origAtts); if ( $data != null) {return $data;}
     .... a bunch of fancy PHP to generate the menu HTML from the categories goes here ....
     setFunctionTransient(__FUNCTION__, $out, $origAtts);
     return $out;
}

And that's it. 75% faster load time, just like that.

If you inspect this page code, before the first menu up top is an invisible <LI> for reasons I can't recall off the top of my head right this moment, but if you look at it, you will see output from the shortcode transient caching function.

If this is the very first page load since I made a site update, that LI will look something like this:

But if the menus have loaded at least once since my last update, you'll see this:

and the page will have loaded in about a quarter of the time.

If you're the sort of geek who likes this kind of stuff, come on over, we'll have a beer and I'll update the site in front of you and let you see this live. Wait, no, we should meet out in a coffee shop or something, my place is a mess.

Obviously I could get much fancier with this. No doubt recreational programmers will immediately see further optimizations.

I'm going to get this cleaned up, better documented, and posted to my github so it's easier to understand. For, you know, some people.

What I didn't realize in setting that up is that YouTube embeds use <iframe> tags to embed videos, and <iframe> tags block page rendering—the page's onload property, which signals that the page is fully ready to display to the viewer and to remove the spinning "page loader" image I use on this site as pages load—does not fire until every iframe on the page has fully loaded its contents. This caused that page, which currently only has a handful of videos on it, to load very slowly. What's worse, this site's custom menus parse all page contents every time the site is updated to display for word counts, meaning including that page in the menus drastically slowed down the first load of any page of the site after I update anything as the menus are rebuilt.

So I hit upon an elegant solution. I created a shortcode as follows: [ytembed url="http://youtube.com/embedurlhere?blahblahblah"] with optional additional parameters "width" and "float" to set the css width and float properties.

This shortcode creates a <div class="mk_YTembedDiv" data-url="http://youtube.com/embedurlhere?blahblahblah"> with the specified CSS properties. Then a script queued up in wordpress's page footers runs after the javascript event window.onload has fired to indicate the page has fully loaded.  That script checks if the page has any <div class="mk_YTembedDiv"> tag on it. If so, it scans the page to build a list of all of them, and grabbing the data-url attribute from each one, inserts an <iframe> tag into it with the proper attributes to display the video with that embed url.

Therefore, the embedded <iframe> tags to show the videos are only added to the page, and begin loading, after the page has been built and displayed to the user. It does mean there can be a delay after the user starts interacting with the page before the videos appear, but I assume people will read a reviews before wanting to watch the video at the bottom of it, so I don't think this is a problem. And it's still much less inconvenient than the page not displaying at all until every video has loaded.

The code that makes the magic happen resides in a custom plugin I wrote to hold all my shortcodes, and here's the README, code, and license, from my github repo at https://github.com/kupietools/wordpress-non-render-blocking-youtube-embed/: