Gruber and Moltz take on Musk

You may not be into nerdy tech podcasts (although if you’re a reader of this blog it’s probably a higher than average probability), but the first main segment of the latest episode of John Gruber’s The Talk Show, dealing with everyone’s favorite billionaire Elon Musk, is really excellent, for a couple of key points:

1. Musk bought Tesla and SpaceX. He didn’t found them. And both of them seem to be succeeding at their missions largely because they have developed a corporate culture that placates Musk’s whims while largely shielding the companies’ primary objectives from the damage those whims may cause.

2. The Boring Company, however, is not a success, and increasingly seems like it may be intended not to be. It’s easy to see Musk as a “world saving visionary,” if that’s what you want to do. But TBC’s main accomplishment, to date, seems to be squashing large public transportation infrastructure projects. And remember that Musk owns Tesla, too. It’s well established by now that mid-20th century automakers exerted their influence to kill public transportation. (Streetcars used to be everywhere!) And it seems quite plausible that TBC is little more than a front for the same activities on behalf of Tesla in this century.

Debugging WordPress and PHP 8.1: a chicken-and-egg conundrum

If you’re a WordPress developer, trying to debug code on a server that’s running PHP 8.1, you may have noticed an absurd number of deprecation notices overwhelming your efforts to get anything done.

After trying in vain to resolve the issue by updating the value for error_reporting in my server’s php.ini file, I discovered why that doesn’t work, courtesy of a StackExchange answer.

WordPress sets its own value for error_reporting when you turn on WP_DEBUG, ignoring the php.ini value. It kind of has to do this. (Well, not “kind of.”) That’s the only way for WordPress to display more — or less — error output than what’s configured at the server level.

The problem is, when you turn on WP_DEBUG, WordPress shows you everything. Normally that would be desirable, but PHP 8.1 has introduced an unusually large number of deprecation notices in anticipation of PHP 9 imposing strict rules on things that have been generously allowed in earlier PHP versions.

OK, so we know what’s going on. But since a lot of the deprecated code is in WordPress core, or in third-party plugins, there’s not really anything a developer like me can do about fixing these issues. (Sure, I could fix it and submit a pull request, but I’m not currently a WordPress core developer and I am not sure I want to take that on, even in an extremely peripheral way.)

So… uh… how do I just make it stop? That is definitely easier said than done, and the reason is the sequential nature of how code is loaded and executed. “Everything everywhere all at once” is not how it works. WordPress loads one file, that loads another file, that loads several other files, each containing a mix of procedural and object-oriented code, and functions. The way WordPress lets you hook into that flow and insert modifications is… well.. hooks.

Hooks are great, but a) the hook you want has to exist, and b) your code that uses the hook needs to be loaded before WordPress processes the hook. Oh, and of course, c) hooks themselves are functions, so you can’t use them until those functions have been defined.

Hence our problem. The code that tells WordPress to show you all the stuff — errors, warnings, deprecation notices — happens pretty early in the sequence. Specifically (as of WordPress 6.1.1) it is in line 460 of wp-includes/load.php in a function called wp_debug_mode(). By that point, yes, the add_action() and add_filter() functions have been defined. But, WordPress hasn’t actually loaded any plugins yet (even “must-use” plugins in the mu-plugins folder). So if you write a plugin to modify the error_reporting value, it might work, but only on deprecation notices that are generated after your plugin has been loaded, and the ones we’re concerned with are all in WordPress core and get triggered before plugin loading starts.

Realizing this, I thought I might solve the problem by putting my filter into the wp-config.php file, a.k.a. the only “early” file you’re allowed to edit. But nope, can’t do that: the add_filter() function doesn’t exist until wp-includes/plugin.php gets loaded at line 49 of wp-settings.php, which itself gets loaded at the very end of wp-config.php.

Since wp_debug_mode() runs at line 80 of wp-settings.php, that means the only way to do what we’re trying to accomplish is to get it to fire off somewhere within those 31 lines of code inside wp-settings.php. Those lines consist of calls to a handful of low-level functions. I checked the source code of each of them for any hooks — not that it would be correct to use the hooks in any of those functions for this purpose, if they existed — but merely to see if it would even be possible.

There is only one hook in the entire lot, and it’s inside wp_debug_mode() itself. It’s called enable_wp_debug_mode_checks. I wrote my own filter function that leverages that hook to modify error_reporting, and it would work, except for the fact that there’s nowhere to put it. I can’t write any custom code in a plugin or theme to call that filter, because it wouldn’t be loaded yet by the time the filter is applied in wp_debug_mode(). And I can’t put it in wp-config.php because, as noted above, the add_filter() function isn’t even defined yet at that point.

So… there are only two place you can put this code to get it to work: either in wp-settings.php just before line 80, or by just editing the wp_debug_mode() function itself in wp-includes/load.php. And you very much are not supposed to do either of these things, because your changes will get overwritten the next time a WordPress core update runs.

But… what else are you going to do? Well… after going through all of the emotions on my wide spectrum from frustration to rage, I read the comments at the top of wp_debug_mode() that start with a pretty unambiguous statement:

This filter runs before it can be used by plugins. It is designed for non-web runtimes.

OK then.

Also inside the comment is a code example, mirrored in the next reply on the same StackExchange post I linked above. I initially ignored it because I instinctively ignore any PHP code example that includes $GLOBALS… but in this case, it’s apparently the official answer on the matter. Boo.

The code I ended up putting into wp-config.php looks a bit different though:

if (WP_DEBUG) {
  $GLOBALS[‘wp_filter’] = [
    ‘enable_wp_debug_mode_checks’ => [
      10 => [[
        ‘accepted_args’ => 0,
        ‘function’ => function() {
          error_reporting(E_ALL & ~E_DEPRECATED);
          ini_set(‘display_errors’, ‘on’);
          return false;
        },
      ]],
    ],
  ];
}

I’m not sure why the StackExchange poster put the error_reporting() call outside the conditional. I also found I needed to specifically set ini_set('display_errors', 'on'); because returning false from this function causes the rest of wp_debug_mode() not to execute — which we want, but we need to make sure to replicate any of the rest of its functionality that we do need. I probably should add the bit that doesn’t output errors on REST/AJAX calls, but I’ll worry about that when it becomes an issue. I don’t use either of those very often. (Of course the WP admin itself uses AJAX all the time.)

A few reasons why you should keep your old domain name indefinitely, even if you’ve changed your business name and never plan to go back

What follows is a slight reworking of an email I just sent to a client. I think it’s broadly useful enough that it deserves to be shared publicly.

Here’s the scenario: The client’s family business operated for many years under her father’s name, but when he retired and she took over, she changed the name. In the several years since, she has built a strong reputation for the new identity, and she was wondering if it was finally time to let the old domain name lapse.

Short answer: No!

Here’s the longer answer, which also addresses the natural follow-up question: Why?

First, “google” your old domain name. Just go to Google, type the old domain name in the search bar, and see what comes up. You may be surprised how many websites out there still have links to URLs with your old domain.

Assuming you kept the old domain configured as an alias when you built your new website, if you keep the domain, those old links will still work, and redirect to the current site. If you were to let the domain lapse, those links would stop working. (Whether or not anyone is actually clicking those links is another matter, of course. If you have Google Analytics or other site stats, check your referrers for some insight on that.)

The same goes for email. Some people may still have old business cards, or for other reasons might still try sending email to those old addresses. If you have them configured to forward (which, again, you should have done when you initially made the switch), then you’ll still get those messages.

Another thing to keep in mind: if you let the old domain lapse, someone else will be able to register it, and could put it to nefarious use — phishing, scams, or just generally sleazy content. I have seen it happen. Even the best case scenario — no one registering it — will result in it loading a “this domain is available” placeholder page with the domain registrar, which may give people the impression you’ve gone out of business.

Given the relatively low annual cost of a domain registration, my recommendation is that you should keep your old domains registered for as long as you’re in business.

New album: Interference Waves (2022 Singles, Outtakes & Allsorts)

It’s another new album! This isn’t really “new” music, though. It’s a compilation of tracks I recorded this year that weren’t already included on one of the three (!) other albums or one EP that I already released this year. It’s all on Bandcamp now. And on YouTube too, actually.

2-hour music video project: “Auric Strands”

I’ve gotten on a bit of a roll with my Saturday music video projects lately, and I’m starting to get just the slightest iota of traction on my YouTube channel — mostly because of silly stunts I shamelessly promote in the comments on more popular YouTubers’ videos, but possibly people genuinely being interested in what I’m doing — and I’m sure that some if not most of the, as of today, 46 (!) subscribers I have are people I don’t know personally. (I always find it easier to get people who don’t know you to engage with artistic endeavors.)

Anyway… I wrapped up my last video project, and with holiday season in full swing, I knew I couldn’t devote (counts on fingers) 17 hours to this like I typically do, so this time I managed to pull it off, start-to-finish, in two hours. Here’s how it came together.

I had a couple of inspirations at work in this. First, my ongoing interest in the broad, nebulously-defined “Synthwave” subgenre of electronic music. For me, it just means instrumental electronic music with a steady beat and sounds that are evocative of the early- to mid-1980s. (1984 is the magical year for me, YMMV.) There’s a sub-subgenre called “Outrun” that generally features a more driving beat, whereas some Synthwave music tends towards ambient or at least “moody.” It’s named for Out Run, a popular car racing arcade game released by Sega in 1986. I never really played Out Run much, if at all, because at the time (I was in middle school) my parents bought me a computer instead of the latest video game console, and I didn’t have the endless supply of quarters (or transportation to the mall) that I would’ve needed to spend a lot of time in the arcade.

Now, things are different. For the past couple of months I’ve been playing a lot of retro games on my Anbernic RG353M, and last night, after burning myself out on Mother 3, I decided to give the arcade version of Out Run a try, mainly to pay attention to the music. I found it interesting, with some surprisingly jazzy chords, an unusually complex song structure, and of course the driving beat I expected.

Earlier yesterday, I had restrung my Precision Bass with some new La Bella gold flatwound strings, so this morning I wanted to play the bass, and more specifically, I wanted to record the bass. So I picked it up and just started noodling around to come up with a bass line that used a driving 8th note pulse. I knew I was kind of inventing a chord progression as I went, but at the moment I was just focused on the sound and the shape of the bass line. I knew I needed to play with a pick — something I rarely, but not never, do.

Once the bass line came together, I knew I had something good going. It was just after 10 AM, and I decided to see how much I could accomplish by noon. I wanted to write and record an entire song, and produce a video, but I wasn’t sure I could do it all in 2 hours.

tl;dr I did. (OK, this is already way too late for a tl;dr but… anyway, just keep reading now that you’re this far.)

I retreated to the “padded room” in the basement with my bass, my laptop, and my MIDI controller keyboard. At that point I had mentally sketched out a plan to record the bass first, and then drums in the form of LinnDrum samples, and then I would just see where inspiration took me from there.

After the drums were recorded, I layered on two more MIDI synth parts using Alchemy sounds in Logic (first a pad and next an arpeggiator). And then I switched over to my Yamaha Reface CP keyboard to lay down some melodies. The melody in the A section is played with a Rhodes electric piano sound, and the B section with a Hohner clavinet sound.

And that was it! I wrapped up recording by 11 AM, had the mix done in 20 minutes, and spent about another half hour putting together the video in Final Cut before posting it to YouTube at 12:05 PM, roughly 2 hours after I had first picked up my bass with only the vaguest idea of a song in my head. Here’s the end result:

Let’s talk a bit about the structure of the song, as it’s a bit unusual. The chord progression in the A section is a 6-bar loop. The keyboard part is just alternating between a G major chord and a D major chord, but with the bass changing the root under the chords, the progression is effectively:

Emin7 /// | % | Bmin7 /// | % | GMaj9 /// | D/F# /// :||

This is repeated 5 times at the beginning, and 4 times when it returns, then 2 times (I think… I’m writing this from memory!) at the end. Overall this section is essentially in E natural minor (or E Aeolian mode).

The last time the A section is repeated, transitioning into the B section, the bass line goes up to a B, instead of returning to E. The B section, a 4-bar loop with some syncopated chord changes, shifts the key to B natural minor (B Aeolian), introducing C# in the melody, where the A section used C natural. Here the keyboard is alternating between D major and B minor chords, with the bass playing A, F# and B, making the chord progression:

Bmin /// | % | D/A // D/F# | //// :||

Once the overall audio-visual production was done, I just needed to add some title screens. Which, of course, meant coming up with a title. My working title was the somewhat literal and boring “Golden Strings,” which got the point across but was a bit uninspired. So I scanned my brain for synonyms. Immediately the word “Auric” popped into my head. As in Auric Goldfinger. Perfect. But then I needed a synonym for “string” as well, and there I resorted to an online thesaurus. Not because I couldn’t think of another word on my own so much as I couldn’t think of a good one fast enough as my noon deadline was fast approaching. There amongst a bunch of real clunkers — twine, cord, ropethong, seriously? — I spotted the perfect choice: “strand.”

“Auric Strands” it is. It wasn’t hard, then, to find a font in my library that fit perfectly. (It’s Big Shoulders Inline Display, if you’re into that sort of thing.) And so the project was done, and just in time!

If you like the song, you can download it on Bandcamp. Thanks for listening! And watching! And reading!